]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
unicode character events
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652
1653 wxPyInstance_Check,
1654 wxPySwigInstance_Check,
1655
1656 wxPyCheckForApp
1657
1658 };
1659
1660 #endif
1661
1662
1663 #if !WXWIN_COMPATIBILITY_2_4
1664 #define wxHIDE_READONLY 0
1665 #endif
1666
1667
1668 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1669 #define SWIG_From_int PyInt_FromLong
1670 /*@@*/
1671
1672
1673 #if ! wxUSE_HOTKEY
1674 enum wxHotkeyModifier
1675 {
1676 wxMOD_NONE = 0,
1677 wxMOD_ALT = 1,
1678 wxMOD_CONTROL = 2,
1679 wxMOD_SHIFT = 4,
1680 wxMOD_WIN = 8
1681 };
1682 #define wxEVT_HOTKEY 9999
1683 #endif
1684
1685 static const wxString wxPyEmptyString(wxEmptyString);
1686 static wxString wxObject_GetClassName(wxObject *self){
1687 return self->GetClassInfo()->GetClassName();
1688 }
1689 static void wxObject_Destroy(wxObject *self){
1690 delete self;
1691 }
1692
1693 #ifndef __WXMAC__
1694 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1695 #endif
1696
1697
1698 #include <limits.h>
1699
1700
1701 SWIGINTERN int
1702 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1703 const char *errmsg)
1704 {
1705 if (value < min_value) {
1706 if (errmsg) {
1707 PyErr_Format(PyExc_OverflowError,
1708 "value %ld is less than '%s' minimum %ld",
1709 value, errmsg, min_value);
1710 }
1711 return 0;
1712 } else if (value > max_value) {
1713 if (errmsg) {
1714 PyErr_Format(PyExc_OverflowError,
1715 "value %ld is greater than '%s' maximum %ld",
1716 value, errmsg, max_value);
1717 }
1718 return 0;
1719 }
1720 return 1;
1721 }
1722
1723
1724 SWIGINTERN int
1725 SWIG_AsVal_long(PyObject* obj, long* val)
1726 {
1727 if (PyNumber_Check(obj)) {
1728 if (val) *val = PyInt_AsLong(obj);
1729 return 1;
1730 }
1731 else {
1732 SWIG_type_error("number", obj);
1733 }
1734 return 0;
1735 }
1736
1737
1738 #if INT_MAX != LONG_MAX
1739 SWIGINTERN int
1740 SWIG_AsVal_int(PyObject *obj, int *val)
1741 {
1742 const char* errmsg = val ? "int" : (char*)0;
1743 long v;
1744 if (SWIG_AsVal_long(obj, &v)) {
1745 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1746 if (val) *val = (int)(v);
1747 return 1;
1748 } else {
1749 return 0;
1750 }
1751 } else {
1752 PyErr_Clear();
1753 }
1754 if (val) {
1755 SWIG_type_error(errmsg, obj);
1756 }
1757 return 0;
1758 }
1759 #else
1760 SWIGINTERNSHORT int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 return SWIG_AsVal_long(obj,(long*)val);
1764 }
1765 #endif
1766
1767
1768 SWIGINTERNSHORT int
1769 SWIG_As_int(PyObject* obj)
1770 {
1771 int v;
1772 if (!SWIG_AsVal_int(obj, &v)) {
1773 /*
1774 this is needed to make valgrind/purify happier.
1775 */
1776 memset((void*)&v, 0, sizeof(int));
1777 }
1778 return v;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_Check_int(PyObject* obj)
1784 {
1785 return SWIG_AsVal_int(obj, (int*)0);
1786 }
1787
1788 static PyObject *wxSize_Get(wxSize *self){
1789 bool blocked = wxPyBeginBlockThreads();
1790 PyObject* tup = PyTuple_New(2);
1791 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1792 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1793 wxPyEndBlockThreads(blocked);
1794 return tup;
1795 }
1796
1797 SWIGINTERN int
1798 SWIG_AsVal_double(PyObject *obj, double* val)
1799 {
1800 if (PyNumber_Check(obj)) {
1801 if (val) *val = PyFloat_AsDouble(obj);
1802 return 1;
1803 }
1804 else {
1805 SWIG_type_error("number", obj);
1806 }
1807 return 0;
1808 }
1809
1810
1811 SWIGINTERNSHORT double
1812 SWIG_As_double(PyObject* obj)
1813 {
1814 double v;
1815 if (!SWIG_AsVal_double(obj, &v)) {
1816 /*
1817 this is needed to make valgrind/purify happier.
1818 */
1819 memset((void*)&v, 0, sizeof(double));
1820 }
1821 return v;
1822 }
1823
1824
1825 SWIGINTERNSHORT int
1826 SWIG_Check_double(PyObject* obj)
1827 {
1828 return SWIG_AsVal_double(obj, (double*)0);
1829 }
1830
1831
1832 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1833 #define SWIG_From_double PyFloat_FromDouble
1834 /*@@*/
1835
1836 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1837 self->x = x;
1838 self->y = y;
1839 }
1840 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1841 bool blocked = wxPyBeginBlockThreads();
1842 PyObject* tup = PyTuple_New(2);
1843 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1844 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1845 wxPyEndBlockThreads(blocked);
1846 return tup;
1847 }
1848
1849 SWIGINTERNSHORT long
1850 SWIG_As_long(PyObject* obj)
1851 {
1852 long v;
1853 if (!SWIG_AsVal_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNSHORT int
1864 SWIG_Check_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_long(obj, (long*)0);
1867 }
1868
1869 static void wxPoint_Set(wxPoint *self,long x,long y){
1870 self->x = x;
1871 self->y = y;
1872 }
1873 static PyObject *wxPoint_Get(wxPoint *self){
1874 bool blocked = wxPyBeginBlockThreads();
1875 PyObject* tup = PyTuple_New(2);
1876 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1877 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1878 wxPyEndBlockThreads(blocked);
1879 return tup;
1880 }
1881 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1882 self->x = x;
1883 self->y = y;
1884 self->width = width;
1885 self->height = height;
1886 }
1887 static PyObject *wxRect_Get(wxRect *self){
1888 bool blocked = wxPyBeginBlockThreads();
1889 PyObject* tup = PyTuple_New(4);
1890 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1891 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1892 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1893 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1894 wxPyEndBlockThreads(blocked);
1895 return tup;
1896 }
1897
1898 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1899 wxRegion reg1(*r1);
1900 wxRegion reg2(*r2);
1901 wxRect dest(0,0,0,0);
1902 PyObject* obj;
1903
1904 reg1.Intersect(reg2);
1905 dest = reg1.GetBox();
1906
1907 if (dest != wxRect(0,0,0,0)) {
1908 bool blocked = wxPyBeginBlockThreads();
1909 wxRect* newRect = new wxRect(dest);
1910 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1911 wxPyEndBlockThreads(blocked);
1912 return obj;
1913 }
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917
1918
1919 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1920 PyObject* o2;
1921 PyObject* o3;
1922
1923 if (!target) {
1924 target = o;
1925 } else if (target == Py_None) {
1926 Py_DECREF(Py_None);
1927 target = o;
1928 } else {
1929 if (!PyTuple_Check(target)) {
1930 o2 = target;
1931 target = PyTuple_New(1);
1932 PyTuple_SetItem(target, 0, o2);
1933 }
1934 o3 = PyTuple_New(1);
1935 PyTuple_SetItem(o3, 0, o);
1936
1937 o2 = target;
1938 target = PySequence_Concat(o2, o3);
1939 Py_DECREF(o2);
1940 Py_DECREF(o3);
1941 }
1942 return target;
1943 }
1944
1945
1946 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1947 self->m_x = x;
1948 self->m_y = y;
1949 }
1950 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1951 bool blocked = wxPyBeginBlockThreads();
1952 PyObject* tup = PyTuple_New(2);
1953 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1954 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1955 wxPyEndBlockThreads(blocked);
1956 return tup;
1957 }
1958
1959 #include "wx/wxPython/pyistream.h"
1960
1961 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1962 wxInputStream* wxis = wxPyCBInputStream::create(p);
1963 if (wxis)
1964 return new wxPyInputStream(wxis);
1965 else
1966 return NULL;
1967 }
1968
1969 SWIGINTERNSHORT PyObject*
1970 SWIG_From_char(char c)
1971 {
1972 return PyString_FromStringAndSize(&c,1);
1973 }
1974
1975
1976 SWIGINTERNSHORT PyObject*
1977 SWIG_From_unsigned_SS_long(unsigned long value)
1978 {
1979 return (value > LONG_MAX) ?
1980 PyLong_FromUnsignedLong(value)
1981 : PyInt_FromLong((long)(value));
1982 }
1983
1984
1985 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1986 SWIGINTERN int
1987 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1988 {
1989 static swig_type_info* pchar_info = 0;
1990 char* vptr = 0;
1991 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1992 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1993 if (cptr) *cptr = vptr;
1994 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1995 return SWIG_OLDOBJ;
1996 } else {
1997 PyErr_Clear();
1998 if (PyString_Check(obj)) {
1999 if (cptr) {
2000 *cptr = PyString_AS_STRING(obj);
2001 if (psize) {
2002 *psize = PyString_GET_SIZE(obj) + 1;
2003 }
2004 }
2005 return SWIG_PYSTR;
2006 }
2007 }
2008 if (cptr) {
2009 SWIG_type_error("char *", obj);
2010 }
2011 return 0;
2012 }
2013
2014
2015 SWIGINTERN int
2016 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2017 {
2018 char* cptr; size_t csize;
2019 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2020 /* in C you can do:
2021
2022 char x[5] = "hello";
2023
2024 ie, assing the array using an extra '0' char.
2025 */
2026 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2027 if (csize <= size) {
2028 if (val) {
2029 if (csize) memcpy(val, cptr, csize);
2030 if (csize < size) memset(val + csize, 0, size - csize);
2031 }
2032 return 1;
2033 }
2034 }
2035 if (val) {
2036 PyErr_Format(PyExc_TypeError,
2037 "a char array of maximum size %lu is expected",
2038 (unsigned long) size);
2039 }
2040 return 0;
2041 }
2042
2043
2044 SWIGINTERN int
2045 SWIG_AsVal_char(PyObject *obj, char *val)
2046 {
2047 const char* errmsg = val ? "char" : (char*)0;
2048 long v;
2049 if (SWIG_AsVal_long(obj, &v)) {
2050 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2051 if (val) *val = (char)(v);
2052 return 1;
2053 } else {
2054 return 0;
2055 }
2056 } else {
2057 PyErr_Clear();
2058 return SWIG_AsCharArray(obj, val, 1);
2059 }
2060 }
2061
2062
2063 SWIGINTERNSHORT char
2064 SWIG_As_char(PyObject* obj)
2065 {
2066 char v;
2067 if (!SWIG_AsVal_char(obj, &v)) {
2068 /*
2069 this is needed to make valgrind/purify happier.
2070 */
2071 memset((void*)&v, 0, sizeof(char));
2072 }
2073 return v;
2074 }
2075
2076
2077 SWIGINTERNSHORT int
2078 SWIG_Check_char(PyObject* obj)
2079 {
2080 return SWIG_AsVal_char(obj, (char*)0);
2081 }
2082
2083
2084 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2085 #define SWIG_From_long PyInt_FromLong
2086 /*@@*/
2087
2088 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2089 // We use only strings for the streams, not unicode
2090 PyObject* str = PyObject_Str(obj);
2091 if (! str) {
2092 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2093 return;
2094 }
2095 self->Write(PyString_AS_STRING(str),
2096 PyString_GET_SIZE(str));
2097 Py_DECREF(str);
2098 }
2099
2100 #include "wx/wxPython/pyistream.h"
2101
2102
2103 class wxPyFileSystemHandler : public wxFileSystemHandler
2104 {
2105 public:
2106 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2107
2108 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2109 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2110 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2111 DEC_PYCALLBACK_STRING__pure(FindNext);
2112
2113 wxString GetProtocol(const wxString& location) {
2114 return wxFileSystemHandler::GetProtocol(location);
2115 }
2116
2117 wxString GetLeftLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetLeftLocation(location);
2119 }
2120
2121 wxString GetAnchor(const wxString& location) {
2122 return wxFileSystemHandler::GetAnchor(location);
2123 }
2124
2125 wxString GetRightLocation(const wxString& location) {
2126 return wxFileSystemHandler::GetRightLocation(location);
2127 }
2128
2129 wxString GetMimeTypeFromExt(const wxString& location) {
2130 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2131 }
2132
2133 PYPRIVATE;
2134 };
2135
2136
2137 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2138 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2139 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2140 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2141
2142
2143 SWIGINTERN int
2144 SWIG_AsVal_bool(PyObject *obj, bool *val)
2145 {
2146 if (obj == Py_True) {
2147 if (val) *val = true;
2148 return 1;
2149 }
2150 if (obj == Py_False) {
2151 if (val) *val = false;
2152 return 1;
2153 }
2154 int res = 0;
2155 if (SWIG_AsVal_int(obj, &res)) {
2156 if (val) *val = res ? true : false;
2157 return 1;
2158 } else {
2159 PyErr_Clear();
2160 }
2161 if (val) {
2162 SWIG_type_error("bool", obj);
2163 }
2164 return 0;
2165 }
2166
2167
2168 SWIGINTERNSHORT bool
2169 SWIG_As_bool(PyObject* obj)
2170 {
2171 bool v;
2172 if (!SWIG_AsVal_bool(obj, &v)) {
2173 /*
2174 this is needed to make valgrind/purify happier.
2175 */
2176 memset((void*)&v, 0, sizeof(bool));
2177 }
2178 return v;
2179 }
2180
2181
2182 SWIGINTERNSHORT int
2183 SWIG_Check_bool(PyObject* obj)
2184 {
2185 return SWIG_AsVal_bool(obj, (bool*)0);
2186 }
2187
2188 static wxString FileSystem_URLToFileName(wxString const &url){
2189 wxFileName fname = wxFileSystem::URLToFileName(url);
2190 return fname.GetFullPath();
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2194 wxImage& image,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, image, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2200 const wxBitmap& bitmap,
2201 long type) {
2202 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2203 }
2204
2205 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2206 PyObject* data) {
2207 if (! PyString_Check(data)) {
2208 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2209 "Expected string object"));
2210 return;
2211 }
2212
2213 bool blocked = wxPyBeginBlockThreads();
2214 void* ptr = (void*)PyString_AsString(data);
2215 size_t size = PyString_Size(data);
2216 wxPyEndBlockThreads(blocked);
2217
2218 wxMemoryFSHandler::AddFile(filename, ptr, size);
2219 }
2220
2221
2222 #include "wx/wxPython/pyistream.h"
2223
2224
2225 SWIGINTERN int
2226 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2227 {
2228 long v = 0;
2229 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2230 SWIG_type_error("unsigned number", obj);
2231 }
2232 else if (val)
2233 *val = (unsigned long)v;
2234 return 1;
2235 }
2236
2237
2238 SWIGINTERNSHORT int
2239 SWIG_CheckUnsignedLongInRange(unsigned long value,
2240 unsigned long max_value,
2241 const char *errmsg)
2242 {
2243 if (value > max_value) {
2244 if (errmsg) {
2245 PyErr_Format(PyExc_OverflowError,
2246 "value %lu is greater than '%s' minimum %lu",
2247 value, errmsg, max_value);
2248 }
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254
2255 SWIGINTERN int
2256 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2257 {
2258 const char* errmsg = val ? "unsigned char" : (char*)0;
2259 unsigned long v;
2260 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2261 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2262 if (val) *val = (unsigned char)(v);
2263 return 1;
2264 } else {
2265 return 0;
2266 }
2267 } else {
2268 PyErr_Clear();
2269 }
2270 if (val) {
2271 SWIG_type_error(errmsg, obj);
2272 }
2273 return 0;
2274 }
2275
2276
2277 SWIGINTERNSHORT unsigned char
2278 SWIG_As_unsigned_SS_char(PyObject* obj)
2279 {
2280 unsigned char v;
2281 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2282 /*
2283 this is needed to make valgrind/purify happier.
2284 */
2285 memset((void*)&v, 0, sizeof(unsigned char));
2286 }
2287 return v;
2288 }
2289
2290
2291 SWIGINTERNSHORT int
2292 SWIG_Check_unsigned_SS_char(PyObject* obj)
2293 {
2294 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2295 }
2296
2297
2298 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2299 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2300 /*@@*/
2301
2302
2303 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2304 if (width > 0 && height > 0)
2305 return new wxImage(width, height, clear);
2306 else
2307 return new wxImage;
2308 }
2309 static wxImage *new_wxImage(wxBitmap const &bitmap){
2310 return new wxImage(bitmap.ConvertToImage());
2311 }
2312 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2313 // Copy the source data so the wxImage can clean it up later
2314 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2315 if (copy == NULL) {
2316 PyErr_NoMemory();
2317 return NULL;
2318 }
2319 memcpy(copy, data, width*height*3);
2320 return new wxImage(width, height, copy, false);
2321 }
2322 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2323 // Copy the source data so the wxImage can clean it up later
2324 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2325 if (dcopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(dcopy, data, width*height*3);
2330 unsigned char* acopy = (unsigned char*)malloc(width*height);
2331 if (acopy == NULL) {
2332 PyErr_NoMemory();
2333 return NULL;
2334 }
2335 memcpy(acopy, alpha, width*height);
2336
2337 return new wxImage(width, height, dcopy, acopy, false);
2338 }
2339 static wxSize wxImage_GetSize(wxImage *self){
2340 wxSize size(self->GetWidth(), self->GetHeight());
2341 return size;
2342 }
2343 static PyObject *wxImage_GetData(wxImage *self){
2344 unsigned char* data = self->GetData();
2345 int len = self->GetWidth() * self->GetHeight() * 3;
2346 PyObject* rv;
2347 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2348 return rv;
2349 }
2350 static void wxImage_SetData(wxImage *self,PyObject *data){
2351 unsigned char* dataPtr;
2352
2353 if (! PyString_Check(data)) {
2354 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2355 "Expected string object"));
2356 return /* NULL */ ;
2357 }
2358
2359 size_t len = self->GetWidth() * self->GetHeight() * 3;
2360 dataPtr = (unsigned char*) malloc(len);
2361 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2362 self->SetData(dataPtr);
2363 // wxImage takes ownership of dataPtr...
2364 }
2365 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2366 unsigned char* data = self->GetData();
2367 int len = self->GetWidth() * self->GetHeight() * 3;
2368 PyObject* rv;
2369 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2370 return rv;
2371 }
2372 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2373 unsigned char* buffer;
2374 int size;
2375
2376 bool blocked = wxPyBeginBlockThreads();
2377 if (!PyArg_Parse(data, "t#", &buffer, &size))
2378 goto done;
2379
2380 if (size != self->GetWidth() * self->GetHeight() * 3) {
2381 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2382 goto done;
2383 }
2384 self->SetData(buffer);
2385 done:
2386 wxPyEndBlockThreads(blocked);
2387 }
2388 static PyObject *wxImage_GetAlphaData(wxImage *self){
2389 unsigned char* data = self->GetAlpha();
2390 if (! data) {
2391 RETURN_NONE();
2392 } else {
2393 int len = self->GetWidth() * self->GetHeight();
2394 PyObject* rv;
2395 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2396 return rv;
2397 }
2398 }
2399 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2400 unsigned char* dataPtr;
2401
2402 if (! PyString_Check(data)) {
2403 PyErr_SetString(PyExc_TypeError, "Expected string object");
2404 return /* NULL */ ;
2405 }
2406
2407 size_t len = self->GetWidth() * self->GetHeight();
2408 dataPtr = (unsigned char*) malloc(len);
2409 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2410 self->SetAlpha(dataPtr);
2411 // wxImage takes ownership of dataPtr...
2412 }
2413 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2414 unsigned char* data = self->GetAlpha();
2415 int len = self->GetWidth() * self->GetHeight();
2416 PyObject* rv;
2417 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2418 return rv;
2419 }
2420 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2421 unsigned char* buffer;
2422 int size;
2423
2424 bool blocked = wxPyBeginBlockThreads();
2425 if (!PyArg_Parse(data, "t#", &buffer, &size))
2426 goto done;
2427
2428 if (size != self->GetWidth() * self->GetHeight()) {
2429 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2430 goto done;
2431 }
2432 self->SetAlpha(buffer);
2433 done:
2434 wxPyEndBlockThreads(blocked);
2435 }
2436
2437 SWIGINTERNSHORT unsigned long
2438 SWIG_As_unsigned_SS_long(PyObject* obj)
2439 {
2440 unsigned long v;
2441 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2442 /*
2443 this is needed to make valgrind/purify happier.
2444 */
2445 memset((void*)&v, 0, sizeof(unsigned long));
2446 }
2447 return v;
2448 }
2449
2450
2451 SWIGINTERNSHORT int
2452 SWIG_Check_unsigned_SS_long(PyObject* obj)
2453 {
2454 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2455 }
2456
2457 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2458 wxBitmap bitmap(*self, depth);
2459 return bitmap;
2460 }
2461 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2462 wxImage mono = self->ConvertToMono( red, green, blue );
2463 wxBitmap bitmap( mono, 1 );
2464 return bitmap;
2465 }
2466 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2467 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2474 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2475 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2476 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2477 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2478 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2479 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2480 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2481
2482 #include <wx/quantize.h>
2483
2484 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2485 return wxQuantize::Quantize(src, dest,
2486 //NULL, // palette
2487 desiredNoColours,
2488 NULL, // eightBitData
2489 flags);
2490 }
2491 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2492 if (PyCallable_Check(func)) {
2493 self->Connect(id, lastId, eventType,
2494 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2495 new wxPyCallback(func));
2496 }
2497 else if (func == Py_None) {
2498 self->Disconnect(id, lastId, eventType,
2499 (wxObjectEventFunction)
2500 &wxPyCallback::EventThunker);
2501 }
2502 else {
2503 wxPyBLOCK_THREADS(
2504 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2505 }
2506 }
2507 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2508 return self->Disconnect(id, lastId, eventType,
2509 (wxObjectEventFunction)
2510 &wxPyCallback::EventThunker);
2511 }
2512 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2513 if (_self && _self != Py_None) {
2514 self->SetClientObject(new wxPyOORClientData(_self, incref));
2515 }
2516 else {
2517 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2518 if (data) {
2519 self->SetClientObject(NULL); // This will delete it too
2520 }
2521 }
2522 }
2523
2524 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2525 #if wxUSE_UNICODE
2526 return self->GetUnicodeKey();
2527 #else
2528 return 0;
2529 #endif
2530 }
2531
2532 #if UINT_MAX < LONG_MAX
2533 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2534 #define SWIG_From_unsigned_SS_int SWIG_From_long
2535 /*@@*/
2536 #else
2537 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2538 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2539 /*@@*/
2540 #endif
2541
2542
2543 #if UINT_MAX != ULONG_MAX
2544 SWIGINTERN int
2545 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2546 {
2547 const char* errmsg = val ? "unsigned int" : (char*)0;
2548 unsigned long v;
2549 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2550 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2551 if (val) *val = (unsigned int)(v);
2552 return 1;
2553 }
2554 } else {
2555 PyErr_Clear();
2556 }
2557 if (val) {
2558 SWIG_type_error(errmsg, obj);
2559 }
2560 return 0;
2561 }
2562 #else
2563 SWIGINTERNSHORT unsigned int
2564 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2565 {
2566 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2567 }
2568 #endif
2569
2570
2571 SWIGINTERNSHORT unsigned int
2572 SWIG_As_unsigned_SS_int(PyObject* obj)
2573 {
2574 unsigned int v;
2575 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2576 /*
2577 this is needed to make valgrind/purify happier.
2578 */
2579 memset((void*)&v, 0, sizeof(unsigned int));
2580 }
2581 return v;
2582 }
2583
2584
2585 SWIGINTERNSHORT int
2586 SWIG_Check_unsigned_SS_int(PyObject* obj)
2587 {
2588 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2589 }
2590
2591 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2592 self->m_size = size;
2593 }
2594 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2595 int count = self->GetNumberOfFiles();
2596 wxString* files = self->GetFiles();
2597 PyObject* list = PyList_New(count);
2598
2599 if (!list) {
2600 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2601 return NULL;
2602 }
2603
2604 for (int i=0; i<count; i++) {
2605 PyList_SetItem(list, i, wx2PyString(files[i]));
2606 }
2607 return list;
2608 }
2609
2610
2611 static wxPyApp *new_wxPyApp(){
2612 wxPythonApp = new wxPyApp();
2613 return wxPythonApp;
2614 }
2615
2616 void wxApp_CleanUp() {
2617 __wxPyCleanup();
2618 }
2619
2620
2621 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2622
2623
2624 SWIGINTERNSHORT int
2625 SWIG_AsCharPtr(PyObject *obj, char **val)
2626 {
2627 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2628 return 1;
2629 }
2630 if (val) {
2631 PyErr_Clear();
2632 SWIG_type_error("char *", obj);
2633 }
2634 return 0;
2635 }
2636
2637
2638 SWIGINTERN PyObject *
2639 SWIG_FromCharPtr(const char* cptr)
2640 {
2641 if (cptr) {
2642 size_t size = strlen(cptr);
2643 if (size > INT_MAX) {
2644 return SWIG_NewPointerObj((char*)(cptr),
2645 SWIG_TypeQuery("char *"), 0);
2646 } else {
2647 if (size != 0) {
2648 return PyString_FromStringAndSize(cptr, size);
2649 } else {
2650 return PyString_FromString(cptr);
2651 }
2652 }
2653 }
2654 Py_INCREF(Py_None);
2655 return Py_None;
2656 }
2657
2658
2659 #ifdef __WXMAC__
2660
2661 // A dummy class that raises an exception if used...
2662 class wxEventLoop
2663 {
2664 public:
2665 wxEventLoop() { wxPyRaiseNotImplemented(); }
2666 int Run() { return 0; }
2667 void Exit(int rc = 0) {}
2668 bool Pending() const { return false; }
2669 bool Dispatch() { return false; }
2670 bool IsRunning() const { return false; }
2671 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2672 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2673 };
2674
2675 #else
2676
2677 #include <wx/evtloop.h>
2678
2679 #endif
2680
2681
2682
2683 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2684 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2685 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2686 static PyObject *wxWindow_GetChildren(wxWindow *self){
2687 wxWindowList& list = self->GetChildren();
2688 return wxPy_ConvertList(&list);
2689 }
2690 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2691 #if wxUSE_HOTKEY
2692 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2693 #else
2694 return false;
2695 #endif
2696 }
2697 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2698
2699
2700
2701 return false;
2702
2703 }
2704 static long wxWindow_GetHandle(wxWindow *self){
2705 return wxPyGetWinHandle(self);
2706 }
2707 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2708 self->AssociateHandle((WXWidget)handle);
2709 }
2710
2711 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2712 return wxWindow::FindWindowById(id, parent);
2713 }
2714
2715 wxWindow* wxFindWindowByName( const wxString& name,
2716 const wxWindow *parent = NULL ) {
2717 return wxWindow::FindWindowByName(name, parent);
2718 }
2719
2720 wxWindow* wxFindWindowByLabel( const wxString& label,
2721 const wxWindow *parent = NULL ) {
2722 return wxWindow::FindWindowByLabel(label, parent);
2723 }
2724
2725
2726 #ifdef __WXMSW__
2727 #include <wx/msw/private.h> // to get wxGetWindowId
2728 #endif
2729
2730
2731 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2732 #ifdef __WXMSW__
2733 WXHWND hWnd = (WXHWND)_hWnd;
2734 long id = wxGetWindowId(hWnd);
2735 wxWindow* win = new wxWindow;
2736 parent->AddChild(win);
2737 win->SetEventHandler(win);
2738 win->SetHWND(hWnd);
2739 win->SetId(id);
2740 win->SubclassWin(hWnd);
2741 win->AdoptAttributesFromHWND();
2742 win->SetupColours();
2743 return win;
2744 #else
2745 wxPyRaiseNotImplemented();
2746 return NULL;
2747 #endif
2748 }
2749
2750
2751 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2752 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2753 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2754
2755 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2756
2757 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2758 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2759 wxMenuItemList& list = self->GetMenuItems();
2760 return wxPy_ConvertList(&list);
2761 }
2762 static const wxString wxPyControlNameStr(wxControlNameStr);
2763 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2764 if (clientData) {
2765 wxPyClientData* data = new wxPyClientData(clientData);
2766 return self->Append(item, data);
2767 } else
2768 return self->Append(item);
2769 }
2770 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2771 if (clientData) {
2772 wxPyClientData* data = new wxPyClientData(clientData);
2773 return self->Insert(item, pos, data);
2774 } else
2775 return self->Insert(item, pos);
2776 }
2777 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2778 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2779 if (data) {
2780 Py_INCREF(data->m_obj);
2781 return data->m_obj;
2782 } else {
2783 Py_INCREF(Py_None);
2784 return Py_None;
2785 }
2786 }
2787 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2788 wxPyClientData* data = new wxPyClientData(clientData);
2789 self->SetClientObject(n, data);
2790 }
2791
2792
2793 static wxSizerItem *new_wxSizerItem(wxWindow *window,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(window, proportion, flag, border, data);
2801 }
2802 static wxSizerItem *new_wxSizerItem(int width,int height,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(width, height, proportion, flag, border, data);
2810 }
2811 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2812 wxPyUserData* data = NULL;
2813 if ( userData ) {
2814 bool blocked = wxPyBeginBlockThreads();
2815 data = new wxPyUserData(userData);
2816 wxPyEndBlockThreads(blocked);
2817 }
2818 return new wxSizerItem(sizer, proportion, flag, border, data);
2819 }
2820
2821 #include <float.h>
2822 SWIGINTERN int
2823 SWIG_CheckDoubleInRange(double value, double min_value,
2824 double max_value, const char* errmsg)
2825 {
2826 if (value < min_value) {
2827 if (errmsg) {
2828 PyErr_Format(PyExc_OverflowError,
2829 "value %g is less than %s minimum %g",
2830 value, errmsg, min_value);
2831 }
2832 return 0;
2833 } else if (value > max_value) {
2834 if (errmsg) {
2835 PyErr_Format(PyExc_OverflowError,
2836 "value %g is greater than %s maximum %g",
2837 value, errmsg, max_value);
2838 }
2839 return 0;
2840 }
2841 return 1;
2842 }
2843
2844
2845 SWIGINTERN int
2846 SWIG_AsVal_float(PyObject *obj, float *val)
2847 {
2848 const char* errmsg = val ? "float" : (char*)0;
2849 double v;
2850 if (SWIG_AsVal_double(obj, &v)) {
2851 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2852 if (val) *val = (float)(v);
2853 return 1;
2854 } else {
2855 return 0;
2856 }
2857 } else {
2858 PyErr_Clear();
2859 }
2860 if (val) {
2861 SWIG_type_error(errmsg, obj);
2862 }
2863 return 0;
2864 }
2865
2866
2867 SWIGINTERNSHORT float
2868 SWIG_As_float(PyObject* obj)
2869 {
2870 float v;
2871 if (!SWIG_AsVal_float(obj, &v)) {
2872 /*
2873 this is needed to make valgrind/purify happier.
2874 */
2875 memset((void*)&v, 0, sizeof(float));
2876 }
2877 return v;
2878 }
2879
2880
2881 SWIGINTERNSHORT int
2882 SWIG_Check_float(PyObject* obj)
2883 {
2884 return SWIG_AsVal_float(obj, (float*)0);
2885 }
2886
2887
2888 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2889 #define SWIG_From_float PyFloat_FromDouble
2890 /*@@*/
2891
2892 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2893 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2894 if (data) {
2895 Py_INCREF(data->m_obj);
2896 return data->m_obj;
2897 } else {
2898 Py_INCREF(Py_None);
2899 return Py_None;
2900 }
2901 }
2902
2903 // Figure out the type of the sizer item
2904
2905 struct wxPySizerItemInfo {
2906 wxPySizerItemInfo()
2907 : window(NULL), sizer(NULL), gotSize(false),
2908 size(wxDefaultSize), gotPos(false), pos(-1)
2909 {}
2910
2911 wxWindow* window;
2912 wxSizer* sizer;
2913 bool gotSize;
2914 wxSize size;
2915 bool gotPos;
2916 int pos;
2917 };
2918
2919 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2920
2921 wxPySizerItemInfo info;
2922 wxSize size;
2923 wxSize* sizePtr = &size;
2924
2925 // Find out what the type of the item is
2926 // try wxWindow
2927 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2928 PyErr_Clear();
2929 info.window = NULL;
2930
2931 // try wxSizer
2932 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2933 PyErr_Clear();
2934 info.sizer = NULL;
2935
2936 // try wxSize or (w,h)
2937 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2938 info.size = *sizePtr;
2939 info.gotSize = true;
2940 }
2941
2942 // or a single int
2943 if (checkIdx && PyInt_Check(item)) {
2944 info.pos = PyInt_AsLong(item);
2945 info.gotPos = true;
2946 }
2947 }
2948 }
2949
2950 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2951 // no expected type, figure out what kind of error message to generate
2952 if ( !checkSize && !checkIdx )
2953 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2954 else if ( checkSize && !checkIdx )
2955 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2956 else if ( !checkSize && checkIdx)
2957 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2958 else
2959 // can this one happen?
2960 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2961 }
2962
2963 return info;
2964 }
2965
2966 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2967 if (!self->GetClientObject())
2968 self->SetClientObject(new wxPyOORClientData(_self));
2969 }
2970 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2971
2972 wxPyUserData* data = NULL;
2973 bool blocked = wxPyBeginBlockThreads();
2974 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2975 if ( userData && (info.window || info.sizer || info.gotSize) )
2976 data = new wxPyUserData(userData);
2977 wxPyEndBlockThreads(blocked);
2978
2979 // Now call the real Add method if a valid item type was found
2980 if ( info.window )
2981 return self->Add(info.window, proportion, flag, border, data);
2982 else if ( info.sizer )
2983 return self->Add(info.sizer, proportion, flag, border, data);
2984 else if (info.gotSize)
2985 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2986 proportion, flag, border, data);
2987 else
2988 return NULL;
2989 }
2990 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2991
2992 wxPyUserData* data = NULL;
2993 bool blocked = wxPyBeginBlockThreads();
2994 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2995 if ( userData && (info.window || info.sizer || info.gotSize) )
2996 data = new wxPyUserData(userData);
2997 wxPyEndBlockThreads(blocked);
2998
2999 // Now call the real Insert method if a valid item type was found
3000 if ( info.window )
3001 return self->Insert(before, info.window, proportion, flag, border, data);
3002 else if ( info.sizer )
3003 return self->Insert(before, info.sizer, proportion, flag, border, data);
3004 else if (info.gotSize)
3005 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3006 proportion, flag, border, data);
3007 else
3008 return NULL;
3009 }
3010 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3011
3012 wxPyUserData* data = NULL;
3013 bool blocked = wxPyBeginBlockThreads();
3014 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3015 if ( userData && (info.window || info.sizer || info.gotSize) )
3016 data = new wxPyUserData(userData);
3017 wxPyEndBlockThreads(blocked);
3018
3019 // Now call the real Prepend method if a valid item type was found
3020 if ( info.window )
3021 return self->Prepend(info.window, proportion, flag, border, data);
3022 else if ( info.sizer )
3023 return self->Prepend(info.sizer, proportion, flag, border, data);
3024 else if (info.gotSize)
3025 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3026 proportion, flag, border, data);
3027 else
3028 return NULL;
3029 }
3030 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3031 bool blocked = wxPyBeginBlockThreads();
3032 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3033 wxPyEndBlockThreads(blocked);
3034 if ( info.window )
3035 return self->Remove(info.window);
3036 else if ( info.sizer )
3037 return self->Remove(info.sizer);
3038 else if ( info.gotPos )
3039 return self->Remove(info.pos);
3040 else
3041 return false;
3042 }
3043 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3044 bool blocked = wxPyBeginBlockThreads();
3045 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3046 wxPyEndBlockThreads(blocked);
3047 if ( info.window )
3048 return self->Detach(info.window);
3049 else if ( info.sizer )
3050 return self->Detach(info.sizer);
3051 else if ( info.gotPos )
3052 return self->Detach(info.pos);
3053 else
3054 return false;
3055 }
3056 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3057 bool blocked = wxPyBeginBlockThreads();
3058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3059 wxPyEndBlockThreads(blocked);
3060 if ( info.window )
3061 return self->GetItem(info.window);
3062 else if ( info.sizer )
3063 return self->GetItem(info.sizer);
3064 else if ( info.gotPos )
3065 return self->GetItem(info.pos);
3066 else
3067 return NULL;
3068 }
3069 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3070 bool blocked = wxPyBeginBlockThreads();
3071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3072 wxPyEndBlockThreads(blocked);
3073 if ( info.window )
3074 self->SetItemMinSize(info.window, size);
3075 else if ( info.sizer )
3076 self->SetItemMinSize(info.sizer, size);
3077 else if ( info.gotPos )
3078 self->SetItemMinSize(info.pos, size);
3079 }
3080 static PyObject *wxSizer_GetChildren(wxSizer *self){
3081 wxSizerItemList& list = self->GetChildren();
3082 return wxPy_ConvertList(&list);
3083 }
3084 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3085 bool blocked = wxPyBeginBlockThreads();
3086 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3087 wxPyEndBlockThreads(blocked);
3088 if ( info.window )
3089 return self->Show(info.window, show, recursive);
3090 else if ( info.sizer )
3091 return self->Show(info.sizer, show, recursive);
3092 else if ( info.gotPos )
3093 return self->Show(info.pos, show);
3094 else
3095 return false;
3096 }
3097 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3098 bool blocked = wxPyBeginBlockThreads();
3099 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3100 wxPyEndBlockThreads(blocked);
3101 if ( info.window )
3102 return self->IsShown(info.window);
3103 else if ( info.sizer )
3104 return self->IsShown(info.sizer);
3105 else if ( info.gotPos )
3106 return self->IsShown(info.pos);
3107 else
3108 return false;
3109 }
3110
3111 // See pyclasses.h
3112 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3113 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3114 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3115
3116
3117
3118
3119 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3120 {
3121 if (source == Py_None) {
3122 **obj = wxGBPosition(-1,-1);
3123 return true;
3124 }
3125 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3126 }
3127
3128 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3129 {
3130 if (source == Py_None) {
3131 **obj = wxGBSpan(-1,-1);
3132 return true;
3133 }
3134 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3135 }
3136
3137
3138 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3139 self->SetRow(row);
3140 self->SetCol(col);
3141 }
3142 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3143 bool blocked = wxPyBeginBlockThreads();
3144 PyObject* tup = PyTuple_New(2);
3145 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3146 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3147 wxPyEndBlockThreads(blocked);
3148 return tup;
3149 }
3150 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3151 self->SetRowspan(rowspan);
3152 self->SetColspan(colspan);
3153 }
3154 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3155 bool blocked = wxPyBeginBlockThreads();
3156 PyObject* tup = PyTuple_New(2);
3157 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3158 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3159 wxPyEndBlockThreads(blocked);
3160 return tup;
3161 }
3162 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,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(window, pos, span, flag, border, data);
3170 }
3171 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,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(sizer, pos, span, flag, border, data);
3179 }
3180 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3181 wxPyUserData* data = NULL;
3182 if ( userData ) {
3183 bool blocked = wxPyBeginBlockThreads();
3184 data = new wxPyUserData(userData);
3185 wxPyEndBlockThreads(blocked);
3186 }
3187 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3188 }
3189 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3190 int row, col;
3191 self->GetEndPos(row, col);
3192 return wxGBPosition(row, col);
3193 }
3194 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3195
3196 wxPyUserData* data = NULL;
3197 bool blocked = wxPyBeginBlockThreads();
3198 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3199 if ( userData && (info.window || info.sizer || info.gotSize) )
3200 data = new wxPyUserData(userData);
3201 wxPyEndBlockThreads(blocked);
3202
3203 // Now call the real Add method if a valid item type was found
3204 if ( info.window )
3205 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3206 else if ( info.sizer )
3207 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3208 else if (info.gotSize)
3209 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3210 pos, span, flag, border, data);
3211 return NULL;
3212 }
3213
3214
3215 #ifdef __cplusplus
3216 extern "C" {
3217 #endif
3218 static int _wrap_EmptyString_set(PyObject *) {
3219 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3220 return 1;
3221 }
3222
3223
3224 static PyObject *_wrap_EmptyString_get(void) {
3225 PyObject *pyobj;
3226
3227 {
3228 #if wxUSE_UNICODE
3229 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3230 #else
3231 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3232 #endif
3233 }
3234 return pyobj;
3235 }
3236
3237
3238 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3239 PyObject *resultobj;
3240 wxObject *arg1 = (wxObject *) 0 ;
3241 wxString result;
3242 PyObject * obj0 = 0 ;
3243 char *kwnames[] = {
3244 (char *) "self", NULL
3245 };
3246
3247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3249 if (SWIG_arg_fail(1)) SWIG_fail;
3250 {
3251 PyThreadState* __tstate = wxPyBeginAllowThreads();
3252 result = wxObject_GetClassName(arg1);
3253
3254 wxPyEndAllowThreads(__tstate);
3255 if (PyErr_Occurred()) SWIG_fail;
3256 }
3257 {
3258 #if wxUSE_UNICODE
3259 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3260 #else
3261 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3262 #endif
3263 }
3264 return resultobj;
3265 fail:
3266 return NULL;
3267 }
3268
3269
3270 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3271 PyObject *resultobj;
3272 wxObject *arg1 = (wxObject *) 0 ;
3273 PyObject * obj0 = 0 ;
3274 char *kwnames[] = {
3275 (char *) "self", NULL
3276 };
3277
3278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3280 if (SWIG_arg_fail(1)) SWIG_fail;
3281 {
3282 PyThreadState* __tstate = wxPyBeginAllowThreads();
3283 wxObject_Destroy(arg1);
3284
3285 wxPyEndAllowThreads(__tstate);
3286 if (PyErr_Occurred()) SWIG_fail;
3287 }
3288 Py_INCREF(Py_None); resultobj = Py_None;
3289 return resultobj;
3290 fail:
3291 return NULL;
3292 }
3293
3294
3295 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3296 PyObject *obj;
3297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3298 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3299 Py_INCREF(obj);
3300 return Py_BuildValue((char *)"");
3301 }
3302 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3303 PyObject *resultobj;
3304 wxSize *arg1 = (wxSize *) 0 ;
3305 int arg2 ;
3306 PyObject * obj0 = 0 ;
3307 PyObject * obj1 = 0 ;
3308 char *kwnames[] = {
3309 (char *) "self",(char *) "x", NULL
3310 };
3311
3312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3314 if (SWIG_arg_fail(1)) SWIG_fail;
3315 {
3316 arg2 = (int)(SWIG_As_int(obj1));
3317 if (SWIG_arg_fail(2)) SWIG_fail;
3318 }
3319 if (arg1) (arg1)->x = arg2;
3320
3321 Py_INCREF(Py_None); resultobj = Py_None;
3322 return resultobj;
3323 fail:
3324 return NULL;
3325 }
3326
3327
3328 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3329 PyObject *resultobj;
3330 wxSize *arg1 = (wxSize *) 0 ;
3331 int result;
3332 PyObject * obj0 = 0 ;
3333 char *kwnames[] = {
3334 (char *) "self", NULL
3335 };
3336
3337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3339 if (SWIG_arg_fail(1)) SWIG_fail;
3340 result = (int) ((arg1)->x);
3341
3342 {
3343 resultobj = SWIG_From_int((int)(result));
3344 }
3345 return resultobj;
3346 fail:
3347 return NULL;
3348 }
3349
3350
3351 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3352 PyObject *resultobj;
3353 wxSize *arg1 = (wxSize *) 0 ;
3354 int arg2 ;
3355 PyObject * obj0 = 0 ;
3356 PyObject * obj1 = 0 ;
3357 char *kwnames[] = {
3358 (char *) "self",(char *) "y", NULL
3359 };
3360
3361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3363 if (SWIG_arg_fail(1)) SWIG_fail;
3364 {
3365 arg2 = (int)(SWIG_As_int(obj1));
3366 if (SWIG_arg_fail(2)) SWIG_fail;
3367 }
3368 if (arg1) (arg1)->y = arg2;
3369
3370 Py_INCREF(Py_None); resultobj = Py_None;
3371 return resultobj;
3372 fail:
3373 return NULL;
3374 }
3375
3376
3377 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3378 PyObject *resultobj;
3379 wxSize *arg1 = (wxSize *) 0 ;
3380 int result;
3381 PyObject * obj0 = 0 ;
3382 char *kwnames[] = {
3383 (char *) "self", NULL
3384 };
3385
3386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3388 if (SWIG_arg_fail(1)) SWIG_fail;
3389 result = (int) ((arg1)->y);
3390
3391 {
3392 resultobj = SWIG_From_int((int)(result));
3393 }
3394 return resultobj;
3395 fail:
3396 return NULL;
3397 }
3398
3399
3400 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3401 PyObject *resultobj;
3402 int arg1 = (int) 0 ;
3403 int arg2 = (int) 0 ;
3404 wxSize *result;
3405 PyObject * obj0 = 0 ;
3406 PyObject * obj1 = 0 ;
3407 char *kwnames[] = {
3408 (char *) "w",(char *) "h", NULL
3409 };
3410
3411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3412 if (obj0) {
3413 {
3414 arg1 = (int)(SWIG_As_int(obj0));
3415 if (SWIG_arg_fail(1)) SWIG_fail;
3416 }
3417 }
3418 if (obj1) {
3419 {
3420 arg2 = (int)(SWIG_As_int(obj1));
3421 if (SWIG_arg_fail(2)) SWIG_fail;
3422 }
3423 }
3424 {
3425 PyThreadState* __tstate = wxPyBeginAllowThreads();
3426 result = (wxSize *)new wxSize(arg1,arg2);
3427
3428 wxPyEndAllowThreads(__tstate);
3429 if (PyErr_Occurred()) SWIG_fail;
3430 }
3431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3432 return resultobj;
3433 fail:
3434 return NULL;
3435 }
3436
3437
3438 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3439 PyObject *resultobj;
3440 wxSize *arg1 = (wxSize *) 0 ;
3441 PyObject * obj0 = 0 ;
3442 char *kwnames[] = {
3443 (char *) "self", NULL
3444 };
3445
3446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3448 if (SWIG_arg_fail(1)) SWIG_fail;
3449 {
3450 PyThreadState* __tstate = wxPyBeginAllowThreads();
3451 delete arg1;
3452
3453 wxPyEndAllowThreads(__tstate);
3454 if (PyErr_Occurred()) SWIG_fail;
3455 }
3456 Py_INCREF(Py_None); resultobj = Py_None;
3457 return resultobj;
3458 fail:
3459 return NULL;
3460 }
3461
3462
3463 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3464 PyObject *resultobj;
3465 wxSize *arg1 = (wxSize *) 0 ;
3466 wxSize *arg2 = 0 ;
3467 bool result;
3468 wxSize temp2 ;
3469 PyObject * obj0 = 0 ;
3470 PyObject * obj1 = 0 ;
3471 char *kwnames[] = {
3472 (char *) "self",(char *) "sz", NULL
3473 };
3474
3475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3477 if (SWIG_arg_fail(1)) SWIG_fail;
3478 {
3479 arg2 = &temp2;
3480 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3481 }
3482 {
3483 PyThreadState* __tstate = wxPyBeginAllowThreads();
3484 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3485
3486 wxPyEndAllowThreads(__tstate);
3487 if (PyErr_Occurred()) SWIG_fail;
3488 }
3489 {
3490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3491 }
3492 return resultobj;
3493 fail:
3494 return NULL;
3495 }
3496
3497
3498 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3499 PyObject *resultobj;
3500 wxSize *arg1 = (wxSize *) 0 ;
3501 wxSize *arg2 = 0 ;
3502 bool result;
3503 wxSize temp2 ;
3504 PyObject * obj0 = 0 ;
3505 PyObject * obj1 = 0 ;
3506 char *kwnames[] = {
3507 (char *) "self",(char *) "sz", NULL
3508 };
3509
3510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3512 if (SWIG_arg_fail(1)) SWIG_fail;
3513 {
3514 arg2 = &temp2;
3515 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3516 }
3517 {
3518 PyThreadState* __tstate = wxPyBeginAllowThreads();
3519 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3520
3521 wxPyEndAllowThreads(__tstate);
3522 if (PyErr_Occurred()) SWIG_fail;
3523 }
3524 {
3525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3526 }
3527 return resultobj;
3528 fail:
3529 return NULL;
3530 }
3531
3532
3533 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3534 PyObject *resultobj;
3535 wxSize *arg1 = (wxSize *) 0 ;
3536 wxSize *arg2 = 0 ;
3537 wxSize result;
3538 wxSize temp2 ;
3539 PyObject * obj0 = 0 ;
3540 PyObject * obj1 = 0 ;
3541 char *kwnames[] = {
3542 (char *) "self",(char *) "sz", NULL
3543 };
3544
3545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3547 if (SWIG_arg_fail(1)) SWIG_fail;
3548 {
3549 arg2 = &temp2;
3550 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3551 }
3552 {
3553 PyThreadState* __tstate = wxPyBeginAllowThreads();
3554 result = (arg1)->operator +((wxSize const &)*arg2);
3555
3556 wxPyEndAllowThreads(__tstate);
3557 if (PyErr_Occurred()) SWIG_fail;
3558 }
3559 {
3560 wxSize * resultptr;
3561 resultptr = new wxSize((wxSize &)(result));
3562 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3563 }
3564 return resultobj;
3565 fail:
3566 return NULL;
3567 }
3568
3569
3570 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3571 PyObject *resultobj;
3572 wxSize *arg1 = (wxSize *) 0 ;
3573 wxSize *arg2 = 0 ;
3574 wxSize result;
3575 wxSize temp2 ;
3576 PyObject * obj0 = 0 ;
3577 PyObject * obj1 = 0 ;
3578 char *kwnames[] = {
3579 (char *) "self",(char *) "sz", NULL
3580 };
3581
3582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3584 if (SWIG_arg_fail(1)) SWIG_fail;
3585 {
3586 arg2 = &temp2;
3587 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3588 }
3589 {
3590 PyThreadState* __tstate = wxPyBeginAllowThreads();
3591 result = (arg1)->operator -((wxSize const &)*arg2);
3592
3593 wxPyEndAllowThreads(__tstate);
3594 if (PyErr_Occurred()) SWIG_fail;
3595 }
3596 {
3597 wxSize * resultptr;
3598 resultptr = new wxSize((wxSize &)(result));
3599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3600 }
3601 return resultobj;
3602 fail:
3603 return NULL;
3604 }
3605
3606
3607 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3608 PyObject *resultobj;
3609 wxSize *arg1 = (wxSize *) 0 ;
3610 wxSize *arg2 = 0 ;
3611 wxSize temp2 ;
3612 PyObject * obj0 = 0 ;
3613 PyObject * obj1 = 0 ;
3614 char *kwnames[] = {
3615 (char *) "self",(char *) "sz", NULL
3616 };
3617
3618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3620 if (SWIG_arg_fail(1)) SWIG_fail;
3621 {
3622 arg2 = &temp2;
3623 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3624 }
3625 {
3626 PyThreadState* __tstate = wxPyBeginAllowThreads();
3627 (arg1)->IncTo((wxSize const &)*arg2);
3628
3629 wxPyEndAllowThreads(__tstate);
3630 if (PyErr_Occurred()) SWIG_fail;
3631 }
3632 Py_INCREF(Py_None); resultobj = Py_None;
3633 return resultobj;
3634 fail:
3635 return NULL;
3636 }
3637
3638
3639 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3640 PyObject *resultobj;
3641 wxSize *arg1 = (wxSize *) 0 ;
3642 wxSize *arg2 = 0 ;
3643 wxSize temp2 ;
3644 PyObject * obj0 = 0 ;
3645 PyObject * obj1 = 0 ;
3646 char *kwnames[] = {
3647 (char *) "self",(char *) "sz", NULL
3648 };
3649
3650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3652 if (SWIG_arg_fail(1)) SWIG_fail;
3653 {
3654 arg2 = &temp2;
3655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3656 }
3657 {
3658 PyThreadState* __tstate = wxPyBeginAllowThreads();
3659 (arg1)->DecTo((wxSize const &)*arg2);
3660
3661 wxPyEndAllowThreads(__tstate);
3662 if (PyErr_Occurred()) SWIG_fail;
3663 }
3664 Py_INCREF(Py_None); resultobj = Py_None;
3665 return resultobj;
3666 fail:
3667 return NULL;
3668 }
3669
3670
3671 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3672 PyObject *resultobj;
3673 wxSize *arg1 = (wxSize *) 0 ;
3674 int arg2 ;
3675 int arg3 ;
3676 PyObject * obj0 = 0 ;
3677 PyObject * obj1 = 0 ;
3678 PyObject * obj2 = 0 ;
3679 char *kwnames[] = {
3680 (char *) "self",(char *) "w",(char *) "h", NULL
3681 };
3682
3683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3685 if (SWIG_arg_fail(1)) SWIG_fail;
3686 {
3687 arg2 = (int)(SWIG_As_int(obj1));
3688 if (SWIG_arg_fail(2)) SWIG_fail;
3689 }
3690 {
3691 arg3 = (int)(SWIG_As_int(obj2));
3692 if (SWIG_arg_fail(3)) SWIG_fail;
3693 }
3694 {
3695 PyThreadState* __tstate = wxPyBeginAllowThreads();
3696 (arg1)->Set(arg2,arg3);
3697
3698 wxPyEndAllowThreads(__tstate);
3699 if (PyErr_Occurred()) SWIG_fail;
3700 }
3701 Py_INCREF(Py_None); resultobj = Py_None;
3702 return resultobj;
3703 fail:
3704 return NULL;
3705 }
3706
3707
3708 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3709 PyObject *resultobj;
3710 wxSize *arg1 = (wxSize *) 0 ;
3711 int arg2 ;
3712 PyObject * obj0 = 0 ;
3713 PyObject * obj1 = 0 ;
3714 char *kwnames[] = {
3715 (char *) "self",(char *) "w", NULL
3716 };
3717
3718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3720 if (SWIG_arg_fail(1)) SWIG_fail;
3721 {
3722 arg2 = (int)(SWIG_As_int(obj1));
3723 if (SWIG_arg_fail(2)) SWIG_fail;
3724 }
3725 {
3726 PyThreadState* __tstate = wxPyBeginAllowThreads();
3727 (arg1)->SetWidth(arg2);
3728
3729 wxPyEndAllowThreads(__tstate);
3730 if (PyErr_Occurred()) SWIG_fail;
3731 }
3732 Py_INCREF(Py_None); resultobj = Py_None;
3733 return resultobj;
3734 fail:
3735 return NULL;
3736 }
3737
3738
3739 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3740 PyObject *resultobj;
3741 wxSize *arg1 = (wxSize *) 0 ;
3742 int arg2 ;
3743 PyObject * obj0 = 0 ;
3744 PyObject * obj1 = 0 ;
3745 char *kwnames[] = {
3746 (char *) "self",(char *) "h", NULL
3747 };
3748
3749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3751 if (SWIG_arg_fail(1)) SWIG_fail;
3752 {
3753 arg2 = (int)(SWIG_As_int(obj1));
3754 if (SWIG_arg_fail(2)) SWIG_fail;
3755 }
3756 {
3757 PyThreadState* __tstate = wxPyBeginAllowThreads();
3758 (arg1)->SetHeight(arg2);
3759
3760 wxPyEndAllowThreads(__tstate);
3761 if (PyErr_Occurred()) SWIG_fail;
3762 }
3763 Py_INCREF(Py_None); resultobj = Py_None;
3764 return resultobj;
3765 fail:
3766 return NULL;
3767 }
3768
3769
3770 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3771 PyObject *resultobj;
3772 wxSize *arg1 = (wxSize *) 0 ;
3773 int result;
3774 PyObject * obj0 = 0 ;
3775 char *kwnames[] = {
3776 (char *) "self", NULL
3777 };
3778
3779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3781 if (SWIG_arg_fail(1)) SWIG_fail;
3782 {
3783 PyThreadState* __tstate = wxPyBeginAllowThreads();
3784 result = (int)((wxSize const *)arg1)->GetWidth();
3785
3786 wxPyEndAllowThreads(__tstate);
3787 if (PyErr_Occurred()) SWIG_fail;
3788 }
3789 {
3790 resultobj = SWIG_From_int((int)(result));
3791 }
3792 return resultobj;
3793 fail:
3794 return NULL;
3795 }
3796
3797
3798 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3799 PyObject *resultobj;
3800 wxSize *arg1 = (wxSize *) 0 ;
3801 int result;
3802 PyObject * obj0 = 0 ;
3803 char *kwnames[] = {
3804 (char *) "self", NULL
3805 };
3806
3807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3809 if (SWIG_arg_fail(1)) SWIG_fail;
3810 {
3811 PyThreadState* __tstate = wxPyBeginAllowThreads();
3812 result = (int)((wxSize const *)arg1)->GetHeight();
3813
3814 wxPyEndAllowThreads(__tstate);
3815 if (PyErr_Occurred()) SWIG_fail;
3816 }
3817 {
3818 resultobj = SWIG_From_int((int)(result));
3819 }
3820 return resultobj;
3821 fail:
3822 return NULL;
3823 }
3824
3825
3826 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3827 PyObject *resultobj;
3828 wxSize *arg1 = (wxSize *) 0 ;
3829 bool result;
3830 PyObject * obj0 = 0 ;
3831 char *kwnames[] = {
3832 (char *) "self", NULL
3833 };
3834
3835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3837 if (SWIG_arg_fail(1)) SWIG_fail;
3838 {
3839 PyThreadState* __tstate = wxPyBeginAllowThreads();
3840 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3841
3842 wxPyEndAllowThreads(__tstate);
3843 if (PyErr_Occurred()) SWIG_fail;
3844 }
3845 {
3846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3847 }
3848 return resultobj;
3849 fail:
3850 return NULL;
3851 }
3852
3853
3854 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3855 PyObject *resultobj;
3856 wxSize *arg1 = (wxSize *) 0 ;
3857 wxSize *arg2 = 0 ;
3858 wxSize temp2 ;
3859 PyObject * obj0 = 0 ;
3860 PyObject * obj1 = 0 ;
3861 char *kwnames[] = {
3862 (char *) "self",(char *) "size", NULL
3863 };
3864
3865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3867 if (SWIG_arg_fail(1)) SWIG_fail;
3868 {
3869 arg2 = &temp2;
3870 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3871 }
3872 {
3873 PyThreadState* __tstate = wxPyBeginAllowThreads();
3874 (arg1)->SetDefaults((wxSize const &)*arg2);
3875
3876 wxPyEndAllowThreads(__tstate);
3877 if (PyErr_Occurred()) SWIG_fail;
3878 }
3879 Py_INCREF(Py_None); resultobj = Py_None;
3880 return resultobj;
3881 fail:
3882 return NULL;
3883 }
3884
3885
3886 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3887 PyObject *resultobj;
3888 wxSize *arg1 = (wxSize *) 0 ;
3889 PyObject *result;
3890 PyObject * obj0 = 0 ;
3891 char *kwnames[] = {
3892 (char *) "self", NULL
3893 };
3894
3895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3897 if (SWIG_arg_fail(1)) SWIG_fail;
3898 {
3899 PyThreadState* __tstate = wxPyBeginAllowThreads();
3900 result = (PyObject *)wxSize_Get(arg1);
3901
3902 wxPyEndAllowThreads(__tstate);
3903 if (PyErr_Occurred()) SWIG_fail;
3904 }
3905 resultobj = result;
3906 return resultobj;
3907 fail:
3908 return NULL;
3909 }
3910
3911
3912 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3913 PyObject *obj;
3914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3915 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3916 Py_INCREF(obj);
3917 return Py_BuildValue((char *)"");
3918 }
3919 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3920 PyObject *resultobj;
3921 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3922 double arg2 ;
3923 PyObject * obj0 = 0 ;
3924 PyObject * obj1 = 0 ;
3925 char *kwnames[] = {
3926 (char *) "self",(char *) "x", NULL
3927 };
3928
3929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3931 if (SWIG_arg_fail(1)) SWIG_fail;
3932 {
3933 arg2 = (double)(SWIG_As_double(obj1));
3934 if (SWIG_arg_fail(2)) SWIG_fail;
3935 }
3936 if (arg1) (arg1)->x = arg2;
3937
3938 Py_INCREF(Py_None); resultobj = Py_None;
3939 return resultobj;
3940 fail:
3941 return NULL;
3942 }
3943
3944
3945 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3946 PyObject *resultobj;
3947 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3948 double result;
3949 PyObject * obj0 = 0 ;
3950 char *kwnames[] = {
3951 (char *) "self", NULL
3952 };
3953
3954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3956 if (SWIG_arg_fail(1)) SWIG_fail;
3957 result = (double) ((arg1)->x);
3958
3959 {
3960 resultobj = SWIG_From_double((double)(result));
3961 }
3962 return resultobj;
3963 fail:
3964 return NULL;
3965 }
3966
3967
3968 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3969 PyObject *resultobj;
3970 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3971 double arg2 ;
3972 PyObject * obj0 = 0 ;
3973 PyObject * obj1 = 0 ;
3974 char *kwnames[] = {
3975 (char *) "self",(char *) "y", NULL
3976 };
3977
3978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3980 if (SWIG_arg_fail(1)) SWIG_fail;
3981 {
3982 arg2 = (double)(SWIG_As_double(obj1));
3983 if (SWIG_arg_fail(2)) SWIG_fail;
3984 }
3985 if (arg1) (arg1)->y = arg2;
3986
3987 Py_INCREF(Py_None); resultobj = Py_None;
3988 return resultobj;
3989 fail:
3990 return NULL;
3991 }
3992
3993
3994 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3995 PyObject *resultobj;
3996 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3997 double result;
3998 PyObject * obj0 = 0 ;
3999 char *kwnames[] = {
4000 (char *) "self", NULL
4001 };
4002
4003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4005 if (SWIG_arg_fail(1)) SWIG_fail;
4006 result = (double) ((arg1)->y);
4007
4008 {
4009 resultobj = SWIG_From_double((double)(result));
4010 }
4011 return resultobj;
4012 fail:
4013 return NULL;
4014 }
4015
4016
4017 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4018 PyObject *resultobj;
4019 double arg1 = (double) 0.0 ;
4020 double arg2 = (double) 0.0 ;
4021 wxRealPoint *result;
4022 PyObject * obj0 = 0 ;
4023 PyObject * obj1 = 0 ;
4024 char *kwnames[] = {
4025 (char *) "x",(char *) "y", NULL
4026 };
4027
4028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4029 if (obj0) {
4030 {
4031 arg1 = (double)(SWIG_As_double(obj0));
4032 if (SWIG_arg_fail(1)) SWIG_fail;
4033 }
4034 }
4035 if (obj1) {
4036 {
4037 arg2 = (double)(SWIG_As_double(obj1));
4038 if (SWIG_arg_fail(2)) SWIG_fail;
4039 }
4040 }
4041 {
4042 PyThreadState* __tstate = wxPyBeginAllowThreads();
4043 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4044
4045 wxPyEndAllowThreads(__tstate);
4046 if (PyErr_Occurred()) SWIG_fail;
4047 }
4048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4049 return resultobj;
4050 fail:
4051 return NULL;
4052 }
4053
4054
4055 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4056 PyObject *resultobj;
4057 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4058 PyObject * obj0 = 0 ;
4059 char *kwnames[] = {
4060 (char *) "self", NULL
4061 };
4062
4063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4065 if (SWIG_arg_fail(1)) SWIG_fail;
4066 {
4067 PyThreadState* __tstate = wxPyBeginAllowThreads();
4068 delete arg1;
4069
4070 wxPyEndAllowThreads(__tstate);
4071 if (PyErr_Occurred()) SWIG_fail;
4072 }
4073 Py_INCREF(Py_None); resultobj = Py_None;
4074 return resultobj;
4075 fail:
4076 return NULL;
4077 }
4078
4079
4080 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4081 PyObject *resultobj;
4082 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4083 wxRealPoint *arg2 = 0 ;
4084 bool result;
4085 wxRealPoint temp2 ;
4086 PyObject * obj0 = 0 ;
4087 PyObject * obj1 = 0 ;
4088 char *kwnames[] = {
4089 (char *) "self",(char *) "pt", NULL
4090 };
4091
4092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4094 if (SWIG_arg_fail(1)) SWIG_fail;
4095 {
4096 arg2 = &temp2;
4097 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4098 }
4099 {
4100 PyThreadState* __tstate = wxPyBeginAllowThreads();
4101 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4102
4103 wxPyEndAllowThreads(__tstate);
4104 if (PyErr_Occurred()) SWIG_fail;
4105 }
4106 {
4107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4108 }
4109 return resultobj;
4110 fail:
4111 return NULL;
4112 }
4113
4114
4115 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4116 PyObject *resultobj;
4117 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4118 wxRealPoint *arg2 = 0 ;
4119 bool result;
4120 wxRealPoint temp2 ;
4121 PyObject * obj0 = 0 ;
4122 PyObject * obj1 = 0 ;
4123 char *kwnames[] = {
4124 (char *) "self",(char *) "pt", NULL
4125 };
4126
4127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4129 if (SWIG_arg_fail(1)) SWIG_fail;
4130 {
4131 arg2 = &temp2;
4132 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4133 }
4134 {
4135 PyThreadState* __tstate = wxPyBeginAllowThreads();
4136 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4137
4138 wxPyEndAllowThreads(__tstate);
4139 if (PyErr_Occurred()) SWIG_fail;
4140 }
4141 {
4142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4143 }
4144 return resultobj;
4145 fail:
4146 return NULL;
4147 }
4148
4149
4150 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4151 PyObject *resultobj;
4152 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4153 wxRealPoint *arg2 = 0 ;
4154 wxRealPoint result;
4155 wxRealPoint temp2 ;
4156 PyObject * obj0 = 0 ;
4157 PyObject * obj1 = 0 ;
4158 char *kwnames[] = {
4159 (char *) "self",(char *) "pt", NULL
4160 };
4161
4162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4164 if (SWIG_arg_fail(1)) SWIG_fail;
4165 {
4166 arg2 = &temp2;
4167 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4168 }
4169 {
4170 PyThreadState* __tstate = wxPyBeginAllowThreads();
4171 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4172
4173 wxPyEndAllowThreads(__tstate);
4174 if (PyErr_Occurred()) SWIG_fail;
4175 }
4176 {
4177 wxRealPoint * resultptr;
4178 resultptr = new wxRealPoint((wxRealPoint &)(result));
4179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4180 }
4181 return resultobj;
4182 fail:
4183 return NULL;
4184 }
4185
4186
4187 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4188 PyObject *resultobj;
4189 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4190 wxRealPoint *arg2 = 0 ;
4191 wxRealPoint result;
4192 wxRealPoint temp2 ;
4193 PyObject * obj0 = 0 ;
4194 PyObject * obj1 = 0 ;
4195 char *kwnames[] = {
4196 (char *) "self",(char *) "pt", NULL
4197 };
4198
4199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4201 if (SWIG_arg_fail(1)) SWIG_fail;
4202 {
4203 arg2 = &temp2;
4204 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4205 }
4206 {
4207 PyThreadState* __tstate = wxPyBeginAllowThreads();
4208 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4209
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 {
4214 wxRealPoint * resultptr;
4215 resultptr = new wxRealPoint((wxRealPoint &)(result));
4216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4217 }
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4225 PyObject *resultobj;
4226 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4227 double arg2 ;
4228 double arg3 ;
4229 PyObject * obj0 = 0 ;
4230 PyObject * obj1 = 0 ;
4231 PyObject * obj2 = 0 ;
4232 char *kwnames[] = {
4233 (char *) "self",(char *) "x",(char *) "y", NULL
4234 };
4235
4236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4238 if (SWIG_arg_fail(1)) SWIG_fail;
4239 {
4240 arg2 = (double)(SWIG_As_double(obj1));
4241 if (SWIG_arg_fail(2)) SWIG_fail;
4242 }
4243 {
4244 arg3 = (double)(SWIG_As_double(obj2));
4245 if (SWIG_arg_fail(3)) SWIG_fail;
4246 }
4247 {
4248 PyThreadState* __tstate = wxPyBeginAllowThreads();
4249 wxRealPoint_Set(arg1,arg2,arg3);
4250
4251 wxPyEndAllowThreads(__tstate);
4252 if (PyErr_Occurred()) SWIG_fail;
4253 }
4254 Py_INCREF(Py_None); resultobj = Py_None;
4255 return resultobj;
4256 fail:
4257 return NULL;
4258 }
4259
4260
4261 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4262 PyObject *resultobj;
4263 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4264 PyObject *result;
4265 PyObject * obj0 = 0 ;
4266 char *kwnames[] = {
4267 (char *) "self", NULL
4268 };
4269
4270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4272 if (SWIG_arg_fail(1)) SWIG_fail;
4273 {
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 result = (PyObject *)wxRealPoint_Get(arg1);
4276
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 resultobj = result;
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4288 PyObject *obj;
4289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4290 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4291 Py_INCREF(obj);
4292 return Py_BuildValue((char *)"");
4293 }
4294 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4295 PyObject *resultobj;
4296 wxPoint *arg1 = (wxPoint *) 0 ;
4297 int arg2 ;
4298 PyObject * obj0 = 0 ;
4299 PyObject * obj1 = 0 ;
4300 char *kwnames[] = {
4301 (char *) "self",(char *) "x", NULL
4302 };
4303
4304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4306 if (SWIG_arg_fail(1)) SWIG_fail;
4307 {
4308 arg2 = (int)(SWIG_As_int(obj1));
4309 if (SWIG_arg_fail(2)) SWIG_fail;
4310 }
4311 if (arg1) (arg1)->x = arg2;
4312
4313 Py_INCREF(Py_None); resultobj = Py_None;
4314 return resultobj;
4315 fail:
4316 return NULL;
4317 }
4318
4319
4320 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4321 PyObject *resultobj;
4322 wxPoint *arg1 = (wxPoint *) 0 ;
4323 int result;
4324 PyObject * obj0 = 0 ;
4325 char *kwnames[] = {
4326 (char *) "self", NULL
4327 };
4328
4329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4331 if (SWIG_arg_fail(1)) SWIG_fail;
4332 result = (int) ((arg1)->x);
4333
4334 {
4335 resultobj = SWIG_From_int((int)(result));
4336 }
4337 return resultobj;
4338 fail:
4339 return NULL;
4340 }
4341
4342
4343 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4344 PyObject *resultobj;
4345 wxPoint *arg1 = (wxPoint *) 0 ;
4346 int arg2 ;
4347 PyObject * obj0 = 0 ;
4348 PyObject * obj1 = 0 ;
4349 char *kwnames[] = {
4350 (char *) "self",(char *) "y", NULL
4351 };
4352
4353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4355 if (SWIG_arg_fail(1)) SWIG_fail;
4356 {
4357 arg2 = (int)(SWIG_As_int(obj1));
4358 if (SWIG_arg_fail(2)) SWIG_fail;
4359 }
4360 if (arg1) (arg1)->y = arg2;
4361
4362 Py_INCREF(Py_None); resultobj = Py_None;
4363 return resultobj;
4364 fail:
4365 return NULL;
4366 }
4367
4368
4369 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj;
4371 wxPoint *arg1 = (wxPoint *) 0 ;
4372 int result;
4373 PyObject * obj0 = 0 ;
4374 char *kwnames[] = {
4375 (char *) "self", NULL
4376 };
4377
4378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4380 if (SWIG_arg_fail(1)) SWIG_fail;
4381 result = (int) ((arg1)->y);
4382
4383 {
4384 resultobj = SWIG_From_int((int)(result));
4385 }
4386 return resultobj;
4387 fail:
4388 return NULL;
4389 }
4390
4391
4392 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4393 PyObject *resultobj;
4394 int arg1 = (int) 0 ;
4395 int arg2 = (int) 0 ;
4396 wxPoint *result;
4397 PyObject * obj0 = 0 ;
4398 PyObject * obj1 = 0 ;
4399 char *kwnames[] = {
4400 (char *) "x",(char *) "y", NULL
4401 };
4402
4403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4404 if (obj0) {
4405 {
4406 arg1 = (int)(SWIG_As_int(obj0));
4407 if (SWIG_arg_fail(1)) SWIG_fail;
4408 }
4409 }
4410 if (obj1) {
4411 {
4412 arg2 = (int)(SWIG_As_int(obj1));
4413 if (SWIG_arg_fail(2)) SWIG_fail;
4414 }
4415 }
4416 {
4417 PyThreadState* __tstate = wxPyBeginAllowThreads();
4418 result = (wxPoint *)new wxPoint(arg1,arg2);
4419
4420 wxPyEndAllowThreads(__tstate);
4421 if (PyErr_Occurred()) SWIG_fail;
4422 }
4423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4424 return resultobj;
4425 fail:
4426 return NULL;
4427 }
4428
4429
4430 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4431 PyObject *resultobj;
4432 wxPoint *arg1 = (wxPoint *) 0 ;
4433 PyObject * obj0 = 0 ;
4434 char *kwnames[] = {
4435 (char *) "self", NULL
4436 };
4437
4438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4440 if (SWIG_arg_fail(1)) SWIG_fail;
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 delete arg1;
4444
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 Py_INCREF(Py_None); resultobj = Py_None;
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4456 PyObject *resultobj;
4457 wxPoint *arg1 = (wxPoint *) 0 ;
4458 wxPoint *arg2 = 0 ;
4459 bool result;
4460 wxPoint temp2 ;
4461 PyObject * obj0 = 0 ;
4462 PyObject * obj1 = 0 ;
4463 char *kwnames[] = {
4464 (char *) "self",(char *) "pt", NULL
4465 };
4466
4467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4469 if (SWIG_arg_fail(1)) SWIG_fail;
4470 {
4471 arg2 = &temp2;
4472 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4473 }
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 {
4482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4483 }
4484 return resultobj;
4485 fail:
4486 return NULL;
4487 }
4488
4489
4490 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4491 PyObject *resultobj;
4492 wxPoint *arg1 = (wxPoint *) 0 ;
4493 wxPoint *arg2 = 0 ;
4494 bool result;
4495 wxPoint temp2 ;
4496 PyObject * obj0 = 0 ;
4497 PyObject * obj1 = 0 ;
4498 char *kwnames[] = {
4499 (char *) "self",(char *) "pt", NULL
4500 };
4501
4502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4504 if (SWIG_arg_fail(1)) SWIG_fail;
4505 {
4506 arg2 = &temp2;
4507 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4508 }
4509 {
4510 PyThreadState* __tstate = wxPyBeginAllowThreads();
4511 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4512
4513 wxPyEndAllowThreads(__tstate);
4514 if (PyErr_Occurred()) SWIG_fail;
4515 }
4516 {
4517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4518 }
4519 return resultobj;
4520 fail:
4521 return NULL;
4522 }
4523
4524
4525 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4526 PyObject *resultobj;
4527 wxPoint *arg1 = (wxPoint *) 0 ;
4528 wxPoint *arg2 = 0 ;
4529 wxPoint result;
4530 wxPoint temp2 ;
4531 PyObject * obj0 = 0 ;
4532 PyObject * obj1 = 0 ;
4533 char *kwnames[] = {
4534 (char *) "self",(char *) "pt", NULL
4535 };
4536
4537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4539 if (SWIG_arg_fail(1)) SWIG_fail;
4540 {
4541 arg2 = &temp2;
4542 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4543 }
4544 {
4545 PyThreadState* __tstate = wxPyBeginAllowThreads();
4546 result = (arg1)->operator +((wxPoint const &)*arg2);
4547
4548 wxPyEndAllowThreads(__tstate);
4549 if (PyErr_Occurred()) SWIG_fail;
4550 }
4551 {
4552 wxPoint * resultptr;
4553 resultptr = new wxPoint((wxPoint &)(result));
4554 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4555 }
4556 return resultobj;
4557 fail:
4558 return NULL;
4559 }
4560
4561
4562 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4563 PyObject *resultobj;
4564 wxPoint *arg1 = (wxPoint *) 0 ;
4565 wxPoint *arg2 = 0 ;
4566 wxPoint result;
4567 wxPoint temp2 ;
4568 PyObject * obj0 = 0 ;
4569 PyObject * obj1 = 0 ;
4570 char *kwnames[] = {
4571 (char *) "self",(char *) "pt", NULL
4572 };
4573
4574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4576 if (SWIG_arg_fail(1)) SWIG_fail;
4577 {
4578 arg2 = &temp2;
4579 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4580 }
4581 {
4582 PyThreadState* __tstate = wxPyBeginAllowThreads();
4583 result = (arg1)->operator -((wxPoint const &)*arg2);
4584
4585 wxPyEndAllowThreads(__tstate);
4586 if (PyErr_Occurred()) SWIG_fail;
4587 }
4588 {
4589 wxPoint * resultptr;
4590 resultptr = new wxPoint((wxPoint &)(result));
4591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4592 }
4593 return resultobj;
4594 fail:
4595 return NULL;
4596 }
4597
4598
4599 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4600 PyObject *resultobj;
4601 wxPoint *arg1 = (wxPoint *) 0 ;
4602 wxPoint *arg2 = 0 ;
4603 wxPoint *result;
4604 wxPoint temp2 ;
4605 PyObject * obj0 = 0 ;
4606 PyObject * obj1 = 0 ;
4607 char *kwnames[] = {
4608 (char *) "self",(char *) "pt", NULL
4609 };
4610
4611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4613 if (SWIG_arg_fail(1)) SWIG_fail;
4614 {
4615 arg2 = &temp2;
4616 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4617 }
4618 {
4619 PyThreadState* __tstate = wxPyBeginAllowThreads();
4620 {
4621 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4622 result = (wxPoint *) &_result_ref;
4623 }
4624
4625 wxPyEndAllowThreads(__tstate);
4626 if (PyErr_Occurred()) SWIG_fail;
4627 }
4628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4629 return resultobj;
4630 fail:
4631 return NULL;
4632 }
4633
4634
4635 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4636 PyObject *resultobj;
4637 wxPoint *arg1 = (wxPoint *) 0 ;
4638 wxPoint *arg2 = 0 ;
4639 wxPoint *result;
4640 wxPoint temp2 ;
4641 PyObject * obj0 = 0 ;
4642 PyObject * obj1 = 0 ;
4643 char *kwnames[] = {
4644 (char *) "self",(char *) "pt", NULL
4645 };
4646
4647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4649 if (SWIG_arg_fail(1)) SWIG_fail;
4650 {
4651 arg2 = &temp2;
4652 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4653 }
4654 {
4655 PyThreadState* __tstate = wxPyBeginAllowThreads();
4656 {
4657 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4658 result = (wxPoint *) &_result_ref;
4659 }
4660
4661 wxPyEndAllowThreads(__tstate);
4662 if (PyErr_Occurred()) SWIG_fail;
4663 }
4664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4665 return resultobj;
4666 fail:
4667 return NULL;
4668 }
4669
4670
4671 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj;
4673 wxPoint *arg1 = (wxPoint *) 0 ;
4674 long arg2 ;
4675 long arg3 ;
4676 PyObject * obj0 = 0 ;
4677 PyObject * obj1 = 0 ;
4678 PyObject * obj2 = 0 ;
4679 char *kwnames[] = {
4680 (char *) "self",(char *) "x",(char *) "y", NULL
4681 };
4682
4683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4685 if (SWIG_arg_fail(1)) SWIG_fail;
4686 {
4687 arg2 = (long)(SWIG_As_long(obj1));
4688 if (SWIG_arg_fail(2)) SWIG_fail;
4689 }
4690 {
4691 arg3 = (long)(SWIG_As_long(obj2));
4692 if (SWIG_arg_fail(3)) SWIG_fail;
4693 }
4694 {
4695 PyThreadState* __tstate = wxPyBeginAllowThreads();
4696 wxPoint_Set(arg1,arg2,arg3);
4697
4698 wxPyEndAllowThreads(__tstate);
4699 if (PyErr_Occurred()) SWIG_fail;
4700 }
4701 Py_INCREF(Py_None); resultobj = Py_None;
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj;
4710 wxPoint *arg1 = (wxPoint *) 0 ;
4711 PyObject *result;
4712 PyObject * obj0 = 0 ;
4713 char *kwnames[] = {
4714 (char *) "self", NULL
4715 };
4716
4717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4719 if (SWIG_arg_fail(1)) SWIG_fail;
4720 {
4721 PyThreadState* __tstate = wxPyBeginAllowThreads();
4722 result = (PyObject *)wxPoint_Get(arg1);
4723
4724 wxPyEndAllowThreads(__tstate);
4725 if (PyErr_Occurred()) SWIG_fail;
4726 }
4727 resultobj = result;
4728 return resultobj;
4729 fail:
4730 return NULL;
4731 }
4732
4733
4734 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4735 PyObject *obj;
4736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4737 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4738 Py_INCREF(obj);
4739 return Py_BuildValue((char *)"");
4740 }
4741 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj;
4743 int arg1 = (int) 0 ;
4744 int arg2 = (int) 0 ;
4745 int arg3 = (int) 0 ;
4746 int arg4 = (int) 0 ;
4747 wxRect *result;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 PyObject * obj2 = 0 ;
4751 PyObject * obj3 = 0 ;
4752 char *kwnames[] = {
4753 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4754 };
4755
4756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4757 if (obj0) {
4758 {
4759 arg1 = (int)(SWIG_As_int(obj0));
4760 if (SWIG_arg_fail(1)) SWIG_fail;
4761 }
4762 }
4763 if (obj1) {
4764 {
4765 arg2 = (int)(SWIG_As_int(obj1));
4766 if (SWIG_arg_fail(2)) SWIG_fail;
4767 }
4768 }
4769 if (obj2) {
4770 {
4771 arg3 = (int)(SWIG_As_int(obj2));
4772 if (SWIG_arg_fail(3)) SWIG_fail;
4773 }
4774 }
4775 if (obj3) {
4776 {
4777 arg4 = (int)(SWIG_As_int(obj3));
4778 if (SWIG_arg_fail(4)) SWIG_fail;
4779 }
4780 }
4781 {
4782 PyThreadState* __tstate = wxPyBeginAllowThreads();
4783 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4784
4785 wxPyEndAllowThreads(__tstate);
4786 if (PyErr_Occurred()) SWIG_fail;
4787 }
4788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4789 return resultobj;
4790 fail:
4791 return NULL;
4792 }
4793
4794
4795 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4796 PyObject *resultobj;
4797 wxPoint *arg1 = 0 ;
4798 wxPoint *arg2 = 0 ;
4799 wxRect *result;
4800 wxPoint temp1 ;
4801 wxPoint temp2 ;
4802 PyObject * obj0 = 0 ;
4803 PyObject * obj1 = 0 ;
4804 char *kwnames[] = {
4805 (char *) "topLeft",(char *) "bottomRight", NULL
4806 };
4807
4808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4809 {
4810 arg1 = &temp1;
4811 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4812 }
4813 {
4814 arg2 = &temp2;
4815 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4816 }
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4820
4821 wxPyEndAllowThreads(__tstate);
4822 if (PyErr_Occurred()) SWIG_fail;
4823 }
4824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4825 return resultobj;
4826 fail:
4827 return NULL;
4828 }
4829
4830
4831 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4832 PyObject *resultobj;
4833 wxPoint *arg1 = 0 ;
4834 wxSize *arg2 = 0 ;
4835 wxRect *result;
4836 wxPoint temp1 ;
4837 wxSize temp2 ;
4838 PyObject * obj0 = 0 ;
4839 PyObject * obj1 = 0 ;
4840 char *kwnames[] = {
4841 (char *) "pos",(char *) "size", NULL
4842 };
4843
4844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4845 {
4846 arg1 = &temp1;
4847 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4848 }
4849 {
4850 arg2 = &temp2;
4851 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4852 }
4853 {
4854 PyThreadState* __tstate = wxPyBeginAllowThreads();
4855 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4856
4857 wxPyEndAllowThreads(__tstate);
4858 if (PyErr_Occurred()) SWIG_fail;
4859 }
4860 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4861 return resultobj;
4862 fail:
4863 return NULL;
4864 }
4865
4866
4867 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4868 PyObject *resultobj;
4869 wxSize *arg1 = 0 ;
4870 wxRect *result;
4871 wxSize temp1 ;
4872 PyObject * obj0 = 0 ;
4873 char *kwnames[] = {
4874 (char *) "size", NULL
4875 };
4876
4877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4878 {
4879 arg1 = &temp1;
4880 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4881 }
4882 {
4883 PyThreadState* __tstate = wxPyBeginAllowThreads();
4884 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4885
4886 wxPyEndAllowThreads(__tstate);
4887 if (PyErr_Occurred()) SWIG_fail;
4888 }
4889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4897 PyObject *resultobj;
4898 wxRect *arg1 = (wxRect *) 0 ;
4899 PyObject * obj0 = 0 ;
4900 char *kwnames[] = {
4901 (char *) "self", NULL
4902 };
4903
4904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4906 if (SWIG_arg_fail(1)) SWIG_fail;
4907 {
4908 PyThreadState* __tstate = wxPyBeginAllowThreads();
4909 delete arg1;
4910
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 Py_INCREF(Py_None); resultobj = Py_None;
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4922 PyObject *resultobj;
4923 wxRect *arg1 = (wxRect *) 0 ;
4924 int result;
4925 PyObject * obj0 = 0 ;
4926 char *kwnames[] = {
4927 (char *) "self", NULL
4928 };
4929
4930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4932 if (SWIG_arg_fail(1)) SWIG_fail;
4933 {
4934 PyThreadState* __tstate = wxPyBeginAllowThreads();
4935 result = (int)((wxRect const *)arg1)->GetX();
4936
4937 wxPyEndAllowThreads(__tstate);
4938 if (PyErr_Occurred()) SWIG_fail;
4939 }
4940 {
4941 resultobj = SWIG_From_int((int)(result));
4942 }
4943 return resultobj;
4944 fail:
4945 return NULL;
4946 }
4947
4948
4949 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4950 PyObject *resultobj;
4951 wxRect *arg1 = (wxRect *) 0 ;
4952 int arg2 ;
4953 PyObject * obj0 = 0 ;
4954 PyObject * obj1 = 0 ;
4955 char *kwnames[] = {
4956 (char *) "self",(char *) "x", NULL
4957 };
4958
4959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4961 if (SWIG_arg_fail(1)) SWIG_fail;
4962 {
4963 arg2 = (int)(SWIG_As_int(obj1));
4964 if (SWIG_arg_fail(2)) SWIG_fail;
4965 }
4966 {
4967 PyThreadState* __tstate = wxPyBeginAllowThreads();
4968 (arg1)->SetX(arg2);
4969
4970 wxPyEndAllowThreads(__tstate);
4971 if (PyErr_Occurred()) SWIG_fail;
4972 }
4973 Py_INCREF(Py_None); resultobj = Py_None;
4974 return resultobj;
4975 fail:
4976 return NULL;
4977 }
4978
4979
4980 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4981 PyObject *resultobj;
4982 wxRect *arg1 = (wxRect *) 0 ;
4983 int result;
4984 PyObject * obj0 = 0 ;
4985 char *kwnames[] = {
4986 (char *) "self", NULL
4987 };
4988
4989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4991 if (SWIG_arg_fail(1)) SWIG_fail;
4992 {
4993 PyThreadState* __tstate = wxPyBeginAllowThreads();
4994 result = (int)(arg1)->GetY();
4995
4996 wxPyEndAllowThreads(__tstate);
4997 if (PyErr_Occurred()) SWIG_fail;
4998 }
4999 {
5000 resultobj = SWIG_From_int((int)(result));
5001 }
5002 return resultobj;
5003 fail:
5004 return NULL;
5005 }
5006
5007
5008 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5009 PyObject *resultobj;
5010 wxRect *arg1 = (wxRect *) 0 ;
5011 int arg2 ;
5012 PyObject * obj0 = 0 ;
5013 PyObject * obj1 = 0 ;
5014 char *kwnames[] = {
5015 (char *) "self",(char *) "y", NULL
5016 };
5017
5018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5020 if (SWIG_arg_fail(1)) SWIG_fail;
5021 {
5022 arg2 = (int)(SWIG_As_int(obj1));
5023 if (SWIG_arg_fail(2)) SWIG_fail;
5024 }
5025 {
5026 PyThreadState* __tstate = wxPyBeginAllowThreads();
5027 (arg1)->SetY(arg2);
5028
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 Py_INCREF(Py_None); resultobj = Py_None;
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5040 PyObject *resultobj;
5041 wxRect *arg1 = (wxRect *) 0 ;
5042 int result;
5043 PyObject * obj0 = 0 ;
5044 char *kwnames[] = {
5045 (char *) "self", NULL
5046 };
5047
5048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5050 if (SWIG_arg_fail(1)) SWIG_fail;
5051 {
5052 PyThreadState* __tstate = wxPyBeginAllowThreads();
5053 result = (int)((wxRect const *)arg1)->GetWidth();
5054
5055 wxPyEndAllowThreads(__tstate);
5056 if (PyErr_Occurred()) SWIG_fail;
5057 }
5058 {
5059 resultobj = SWIG_From_int((int)(result));
5060 }
5061 return resultobj;
5062 fail:
5063 return NULL;
5064 }
5065
5066
5067 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5068 PyObject *resultobj;
5069 wxRect *arg1 = (wxRect *) 0 ;
5070 int arg2 ;
5071 PyObject * obj0 = 0 ;
5072 PyObject * obj1 = 0 ;
5073 char *kwnames[] = {
5074 (char *) "self",(char *) "w", NULL
5075 };
5076
5077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5079 if (SWIG_arg_fail(1)) SWIG_fail;
5080 {
5081 arg2 = (int)(SWIG_As_int(obj1));
5082 if (SWIG_arg_fail(2)) SWIG_fail;
5083 }
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 (arg1)->SetWidth(arg2);
5087
5088 wxPyEndAllowThreads(__tstate);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 Py_INCREF(Py_None); resultobj = Py_None;
5092 return resultobj;
5093 fail:
5094 return NULL;
5095 }
5096
5097
5098 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5099 PyObject *resultobj;
5100 wxRect *arg1 = (wxRect *) 0 ;
5101 int result;
5102 PyObject * obj0 = 0 ;
5103 char *kwnames[] = {
5104 (char *) "self", NULL
5105 };
5106
5107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5109 if (SWIG_arg_fail(1)) SWIG_fail;
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 result = (int)((wxRect const *)arg1)->GetHeight();
5113
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 {
5118 resultobj = SWIG_From_int((int)(result));
5119 }
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj;
5128 wxRect *arg1 = (wxRect *) 0 ;
5129 int arg2 ;
5130 PyObject * obj0 = 0 ;
5131 PyObject * obj1 = 0 ;
5132 char *kwnames[] = {
5133 (char *) "self",(char *) "h", NULL
5134 };
5135
5136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5138 if (SWIG_arg_fail(1)) SWIG_fail;
5139 {
5140 arg2 = (int)(SWIG_As_int(obj1));
5141 if (SWIG_arg_fail(2)) SWIG_fail;
5142 }
5143 {
5144 PyThreadState* __tstate = wxPyBeginAllowThreads();
5145 (arg1)->SetHeight(arg2);
5146
5147 wxPyEndAllowThreads(__tstate);
5148 if (PyErr_Occurred()) SWIG_fail;
5149 }
5150 Py_INCREF(Py_None); resultobj = Py_None;
5151 return resultobj;
5152 fail:
5153 return NULL;
5154 }
5155
5156
5157 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5158 PyObject *resultobj;
5159 wxRect *arg1 = (wxRect *) 0 ;
5160 wxPoint result;
5161 PyObject * obj0 = 0 ;
5162 char *kwnames[] = {
5163 (char *) "self", NULL
5164 };
5165
5166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5168 if (SWIG_arg_fail(1)) SWIG_fail;
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 result = ((wxRect const *)arg1)->GetPosition();
5172
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 {
5177 wxPoint * resultptr;
5178 resultptr = new wxPoint((wxPoint &)(result));
5179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5180 }
5181 return resultobj;
5182 fail:
5183 return NULL;
5184 }
5185
5186
5187 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5188 PyObject *resultobj;
5189 wxRect *arg1 = (wxRect *) 0 ;
5190 wxPoint *arg2 = 0 ;
5191 wxPoint temp2 ;
5192 PyObject * obj0 = 0 ;
5193 PyObject * obj1 = 0 ;
5194 char *kwnames[] = {
5195 (char *) "self",(char *) "p", NULL
5196 };
5197
5198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5200 if (SWIG_arg_fail(1)) SWIG_fail;
5201 {
5202 arg2 = &temp2;
5203 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5204 }
5205 {
5206 PyThreadState* __tstate = wxPyBeginAllowThreads();
5207 (arg1)->SetPosition((wxPoint const &)*arg2);
5208
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 Py_INCREF(Py_None); resultobj = Py_None;
5213 return resultobj;
5214 fail:
5215 return NULL;
5216 }
5217
5218
5219 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5220 PyObject *resultobj;
5221 wxRect *arg1 = (wxRect *) 0 ;
5222 wxSize result;
5223 PyObject * obj0 = 0 ;
5224 char *kwnames[] = {
5225 (char *) "self", NULL
5226 };
5227
5228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5230 if (SWIG_arg_fail(1)) SWIG_fail;
5231 {
5232 PyThreadState* __tstate = wxPyBeginAllowThreads();
5233 result = ((wxRect const *)arg1)->GetSize();
5234
5235 wxPyEndAllowThreads(__tstate);
5236 if (PyErr_Occurred()) SWIG_fail;
5237 }
5238 {
5239 wxSize * resultptr;
5240 resultptr = new wxSize((wxSize &)(result));
5241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5242 }
5243 return resultobj;
5244 fail:
5245 return NULL;
5246 }
5247
5248
5249 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5250 PyObject *resultobj;
5251 wxRect *arg1 = (wxRect *) 0 ;
5252 wxSize *arg2 = 0 ;
5253 wxSize temp2 ;
5254 PyObject * obj0 = 0 ;
5255 PyObject * obj1 = 0 ;
5256 char *kwnames[] = {
5257 (char *) "self",(char *) "s", NULL
5258 };
5259
5260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5262 if (SWIG_arg_fail(1)) SWIG_fail;
5263 {
5264 arg2 = &temp2;
5265 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5266 }
5267 {
5268 PyThreadState* __tstate = wxPyBeginAllowThreads();
5269 (arg1)->SetSize((wxSize const &)*arg2);
5270
5271 wxPyEndAllowThreads(__tstate);
5272 if (PyErr_Occurred()) SWIG_fail;
5273 }
5274 Py_INCREF(Py_None); resultobj = Py_None;
5275 return resultobj;
5276 fail:
5277 return NULL;
5278 }
5279
5280
5281 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5282 PyObject *resultobj;
5283 wxRect *arg1 = (wxRect *) 0 ;
5284 wxPoint result;
5285 PyObject * obj0 = 0 ;
5286 char *kwnames[] = {
5287 (char *) "self", NULL
5288 };
5289
5290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5292 if (SWIG_arg_fail(1)) SWIG_fail;
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 result = ((wxRect const *)arg1)->GetTopLeft();
5296
5297 wxPyEndAllowThreads(__tstate);
5298 if (PyErr_Occurred()) SWIG_fail;
5299 }
5300 {
5301 wxPoint * resultptr;
5302 resultptr = new wxPoint((wxPoint &)(result));
5303 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5304 }
5305 return resultobj;
5306 fail:
5307 return NULL;
5308 }
5309
5310
5311 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5312 PyObject *resultobj;
5313 wxRect *arg1 = (wxRect *) 0 ;
5314 wxPoint *arg2 = 0 ;
5315 wxPoint temp2 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char *kwnames[] = {
5319 (char *) "self",(char *) "p", NULL
5320 };
5321
5322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5324 if (SWIG_arg_fail(1)) SWIG_fail;
5325 {
5326 arg2 = &temp2;
5327 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5328 }
5329 {
5330 PyThreadState* __tstate = wxPyBeginAllowThreads();
5331 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5332
5333 wxPyEndAllowThreads(__tstate);
5334 if (PyErr_Occurred()) SWIG_fail;
5335 }
5336 Py_INCREF(Py_None); resultobj = Py_None;
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5344 PyObject *resultobj;
5345 wxRect *arg1 = (wxRect *) 0 ;
5346 wxPoint result;
5347 PyObject * obj0 = 0 ;
5348 char *kwnames[] = {
5349 (char *) "self", NULL
5350 };
5351
5352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5354 if (SWIG_arg_fail(1)) SWIG_fail;
5355 {
5356 PyThreadState* __tstate = wxPyBeginAllowThreads();
5357 result = ((wxRect const *)arg1)->GetBottomRight();
5358
5359 wxPyEndAllowThreads(__tstate);
5360 if (PyErr_Occurred()) SWIG_fail;
5361 }
5362 {
5363 wxPoint * resultptr;
5364 resultptr = new wxPoint((wxPoint &)(result));
5365 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5366 }
5367 return resultobj;
5368 fail:
5369 return NULL;
5370 }
5371
5372
5373 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5374 PyObject *resultobj;
5375 wxRect *arg1 = (wxRect *) 0 ;
5376 wxPoint *arg2 = 0 ;
5377 wxPoint temp2 ;
5378 PyObject * obj0 = 0 ;
5379 PyObject * obj1 = 0 ;
5380 char *kwnames[] = {
5381 (char *) "self",(char *) "p", NULL
5382 };
5383
5384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5386 if (SWIG_arg_fail(1)) SWIG_fail;
5387 {
5388 arg2 = &temp2;
5389 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5390 }
5391 {
5392 PyThreadState* __tstate = wxPyBeginAllowThreads();
5393 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5394
5395 wxPyEndAllowThreads(__tstate);
5396 if (PyErr_Occurred()) SWIG_fail;
5397 }
5398 Py_INCREF(Py_None); resultobj = Py_None;
5399 return resultobj;
5400 fail:
5401 return NULL;
5402 }
5403
5404
5405 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5406 PyObject *resultobj;
5407 wxRect *arg1 = (wxRect *) 0 ;
5408 int result;
5409 PyObject * obj0 = 0 ;
5410 char *kwnames[] = {
5411 (char *) "self", NULL
5412 };
5413
5414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5416 if (SWIG_arg_fail(1)) SWIG_fail;
5417 {
5418 PyThreadState* __tstate = wxPyBeginAllowThreads();
5419 result = (int)((wxRect const *)arg1)->GetLeft();
5420
5421 wxPyEndAllowThreads(__tstate);
5422 if (PyErr_Occurred()) SWIG_fail;
5423 }
5424 {
5425 resultobj = SWIG_From_int((int)(result));
5426 }
5427 return resultobj;
5428 fail:
5429 return NULL;
5430 }
5431
5432
5433 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5434 PyObject *resultobj;
5435 wxRect *arg1 = (wxRect *) 0 ;
5436 int result;
5437 PyObject * obj0 = 0 ;
5438 char *kwnames[] = {
5439 (char *) "self", NULL
5440 };
5441
5442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5444 if (SWIG_arg_fail(1)) SWIG_fail;
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 result = (int)((wxRect const *)arg1)->GetTop();
5448
5449 wxPyEndAllowThreads(__tstate);
5450 if (PyErr_Occurred()) SWIG_fail;
5451 }
5452 {
5453 resultobj = SWIG_From_int((int)(result));
5454 }
5455 return resultobj;
5456 fail:
5457 return NULL;
5458 }
5459
5460
5461 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5462 PyObject *resultobj;
5463 wxRect *arg1 = (wxRect *) 0 ;
5464 int result;
5465 PyObject * obj0 = 0 ;
5466 char *kwnames[] = {
5467 (char *) "self", NULL
5468 };
5469
5470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5472 if (SWIG_arg_fail(1)) SWIG_fail;
5473 {
5474 PyThreadState* __tstate = wxPyBeginAllowThreads();
5475 result = (int)((wxRect const *)arg1)->GetBottom();
5476
5477 wxPyEndAllowThreads(__tstate);
5478 if (PyErr_Occurred()) SWIG_fail;
5479 }
5480 {
5481 resultobj = SWIG_From_int((int)(result));
5482 }
5483 return resultobj;
5484 fail:
5485 return NULL;
5486 }
5487
5488
5489 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5490 PyObject *resultobj;
5491 wxRect *arg1 = (wxRect *) 0 ;
5492 int result;
5493 PyObject * obj0 = 0 ;
5494 char *kwnames[] = {
5495 (char *) "self", NULL
5496 };
5497
5498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5500 if (SWIG_arg_fail(1)) SWIG_fail;
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = (int)((wxRect const *)arg1)->GetRight();
5504
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 {
5509 resultobj = SWIG_From_int((int)(result));
5510 }
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj;
5519 wxRect *arg1 = (wxRect *) 0 ;
5520 int arg2 ;
5521 PyObject * obj0 = 0 ;
5522 PyObject * obj1 = 0 ;
5523 char *kwnames[] = {
5524 (char *) "self",(char *) "left", NULL
5525 };
5526
5527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5529 if (SWIG_arg_fail(1)) SWIG_fail;
5530 {
5531 arg2 = (int)(SWIG_As_int(obj1));
5532 if (SWIG_arg_fail(2)) SWIG_fail;
5533 }
5534 {
5535 PyThreadState* __tstate = wxPyBeginAllowThreads();
5536 (arg1)->SetLeft(arg2);
5537
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 Py_INCREF(Py_None); resultobj = Py_None;
5542 return resultobj;
5543 fail:
5544 return NULL;
5545 }
5546
5547
5548 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5549 PyObject *resultobj;
5550 wxRect *arg1 = (wxRect *) 0 ;
5551 int arg2 ;
5552 PyObject * obj0 = 0 ;
5553 PyObject * obj1 = 0 ;
5554 char *kwnames[] = {
5555 (char *) "self",(char *) "right", NULL
5556 };
5557
5558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5560 if (SWIG_arg_fail(1)) SWIG_fail;
5561 {
5562 arg2 = (int)(SWIG_As_int(obj1));
5563 if (SWIG_arg_fail(2)) SWIG_fail;
5564 }
5565 {
5566 PyThreadState* __tstate = wxPyBeginAllowThreads();
5567 (arg1)->SetRight(arg2);
5568
5569 wxPyEndAllowThreads(__tstate);
5570 if (PyErr_Occurred()) SWIG_fail;
5571 }
5572 Py_INCREF(Py_None); resultobj = Py_None;
5573 return resultobj;
5574 fail:
5575 return NULL;
5576 }
5577
5578
5579 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5580 PyObject *resultobj;
5581 wxRect *arg1 = (wxRect *) 0 ;
5582 int arg2 ;
5583 PyObject * obj0 = 0 ;
5584 PyObject * obj1 = 0 ;
5585 char *kwnames[] = {
5586 (char *) "self",(char *) "top", NULL
5587 };
5588
5589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5591 if (SWIG_arg_fail(1)) SWIG_fail;
5592 {
5593 arg2 = (int)(SWIG_As_int(obj1));
5594 if (SWIG_arg_fail(2)) SWIG_fail;
5595 }
5596 {
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 (arg1)->SetTop(arg2);
5599
5600 wxPyEndAllowThreads(__tstate);
5601 if (PyErr_Occurred()) SWIG_fail;
5602 }
5603 Py_INCREF(Py_None); resultobj = Py_None;
5604 return resultobj;
5605 fail:
5606 return NULL;
5607 }
5608
5609
5610 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5611 PyObject *resultobj;
5612 wxRect *arg1 = (wxRect *) 0 ;
5613 int arg2 ;
5614 PyObject * obj0 = 0 ;
5615 PyObject * obj1 = 0 ;
5616 char *kwnames[] = {
5617 (char *) "self",(char *) "bottom", NULL
5618 };
5619
5620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5622 if (SWIG_arg_fail(1)) SWIG_fail;
5623 {
5624 arg2 = (int)(SWIG_As_int(obj1));
5625 if (SWIG_arg_fail(2)) SWIG_fail;
5626 }
5627 {
5628 PyThreadState* __tstate = wxPyBeginAllowThreads();
5629 (arg1)->SetBottom(arg2);
5630
5631 wxPyEndAllowThreads(__tstate);
5632 if (PyErr_Occurred()) SWIG_fail;
5633 }
5634 Py_INCREF(Py_None); resultobj = Py_None;
5635 return resultobj;
5636 fail:
5637 return NULL;
5638 }
5639
5640
5641 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5642 PyObject *resultobj;
5643 wxRect *arg1 = (wxRect *) 0 ;
5644 int arg2 ;
5645 int arg3 ;
5646 wxRect *result;
5647 PyObject * obj0 = 0 ;
5648 PyObject * obj1 = 0 ;
5649 PyObject * obj2 = 0 ;
5650 char *kwnames[] = {
5651 (char *) "self",(char *) "dx",(char *) "dy", NULL
5652 };
5653
5654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5656 if (SWIG_arg_fail(1)) SWIG_fail;
5657 {
5658 arg2 = (int)(SWIG_As_int(obj1));
5659 if (SWIG_arg_fail(2)) SWIG_fail;
5660 }
5661 {
5662 arg3 = (int)(SWIG_As_int(obj2));
5663 if (SWIG_arg_fail(3)) SWIG_fail;
5664 }
5665 {
5666 PyThreadState* __tstate = wxPyBeginAllowThreads();
5667 {
5668 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5669 result = (wxRect *) &_result_ref;
5670 }
5671
5672 wxPyEndAllowThreads(__tstate);
5673 if (PyErr_Occurred()) SWIG_fail;
5674 }
5675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5676 return resultobj;
5677 fail:
5678 return NULL;
5679 }
5680
5681
5682 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5683 PyObject *resultobj;
5684 wxRect *arg1 = (wxRect *) 0 ;
5685 int arg2 ;
5686 int arg3 ;
5687 wxRect *result;
5688 PyObject * obj0 = 0 ;
5689 PyObject * obj1 = 0 ;
5690 PyObject * obj2 = 0 ;
5691 char *kwnames[] = {
5692 (char *) "self",(char *) "dx",(char *) "dy", NULL
5693 };
5694
5695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5697 if (SWIG_arg_fail(1)) SWIG_fail;
5698 {
5699 arg2 = (int)(SWIG_As_int(obj1));
5700 if (SWIG_arg_fail(2)) SWIG_fail;
5701 }
5702 {
5703 arg3 = (int)(SWIG_As_int(obj2));
5704 if (SWIG_arg_fail(3)) SWIG_fail;
5705 }
5706 {
5707 PyThreadState* __tstate = wxPyBeginAllowThreads();
5708 {
5709 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5710 result = (wxRect *) &_result_ref;
5711 }
5712
5713 wxPyEndAllowThreads(__tstate);
5714 if (PyErr_Occurred()) SWIG_fail;
5715 }
5716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5717 return resultobj;
5718 fail:
5719 return NULL;
5720 }
5721
5722
5723 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5724 PyObject *resultobj;
5725 wxRect *arg1 = (wxRect *) 0 ;
5726 int arg2 ;
5727 int arg3 ;
5728 PyObject * obj0 = 0 ;
5729 PyObject * obj1 = 0 ;
5730 PyObject * obj2 = 0 ;
5731 char *kwnames[] = {
5732 (char *) "self",(char *) "dx",(char *) "dy", NULL
5733 };
5734
5735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5737 if (SWIG_arg_fail(1)) SWIG_fail;
5738 {
5739 arg2 = (int)(SWIG_As_int(obj1));
5740 if (SWIG_arg_fail(2)) SWIG_fail;
5741 }
5742 {
5743 arg3 = (int)(SWIG_As_int(obj2));
5744 if (SWIG_arg_fail(3)) SWIG_fail;
5745 }
5746 {
5747 PyThreadState* __tstate = wxPyBeginAllowThreads();
5748 (arg1)->Offset(arg2,arg3);
5749
5750 wxPyEndAllowThreads(__tstate);
5751 if (PyErr_Occurred()) SWIG_fail;
5752 }
5753 Py_INCREF(Py_None); resultobj = Py_None;
5754 return resultobj;
5755 fail:
5756 return NULL;
5757 }
5758
5759
5760 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5761 PyObject *resultobj;
5762 wxRect *arg1 = (wxRect *) 0 ;
5763 wxPoint *arg2 = 0 ;
5764 wxPoint temp2 ;
5765 PyObject * obj0 = 0 ;
5766 PyObject * obj1 = 0 ;
5767 char *kwnames[] = {
5768 (char *) "self",(char *) "pt", NULL
5769 };
5770
5771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5773 if (SWIG_arg_fail(1)) SWIG_fail;
5774 {
5775 arg2 = &temp2;
5776 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5777 }
5778 {
5779 PyThreadState* __tstate = wxPyBeginAllowThreads();
5780 (arg1)->Offset((wxPoint const &)*arg2);
5781
5782 wxPyEndAllowThreads(__tstate);
5783 if (PyErr_Occurred()) SWIG_fail;
5784 }
5785 Py_INCREF(Py_None); resultobj = Py_None;
5786 return resultobj;
5787 fail:
5788 return NULL;
5789 }
5790
5791
5792 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5793 PyObject *resultobj;
5794 wxRect *arg1 = (wxRect *) 0 ;
5795 wxRect *arg2 = 0 ;
5796 wxRect result;
5797 wxRect temp2 ;
5798 PyObject * obj0 = 0 ;
5799 PyObject * obj1 = 0 ;
5800 char *kwnames[] = {
5801 (char *) "self",(char *) "rect", NULL
5802 };
5803
5804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5806 if (SWIG_arg_fail(1)) SWIG_fail;
5807 {
5808 arg2 = &temp2;
5809 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5810 }
5811 {
5812 PyThreadState* __tstate = wxPyBeginAllowThreads();
5813 result = (arg1)->Intersect((wxRect const &)*arg2);
5814
5815 wxPyEndAllowThreads(__tstate);
5816 if (PyErr_Occurred()) SWIG_fail;
5817 }
5818 {
5819 wxRect * resultptr;
5820 resultptr = new wxRect((wxRect &)(result));
5821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5822 }
5823 return resultobj;
5824 fail:
5825 return NULL;
5826 }
5827
5828
5829 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5830 PyObject *resultobj;
5831 wxRect *arg1 = (wxRect *) 0 ;
5832 wxRect *arg2 = 0 ;
5833 wxRect result;
5834 wxRect temp2 ;
5835 PyObject * obj0 = 0 ;
5836 PyObject * obj1 = 0 ;
5837 char *kwnames[] = {
5838 (char *) "self",(char *) "rect", NULL
5839 };
5840
5841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5843 if (SWIG_arg_fail(1)) SWIG_fail;
5844 {
5845 arg2 = &temp2;
5846 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5847 }
5848 {
5849 PyThreadState* __tstate = wxPyBeginAllowThreads();
5850 result = (arg1)->Union((wxRect const &)*arg2);
5851
5852 wxPyEndAllowThreads(__tstate);
5853 if (PyErr_Occurred()) SWIG_fail;
5854 }
5855 {
5856 wxRect * resultptr;
5857 resultptr = new wxRect((wxRect &)(result));
5858 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5859 }
5860 return resultobj;
5861 fail:
5862 return NULL;
5863 }
5864
5865
5866 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5867 PyObject *resultobj;
5868 wxRect *arg1 = (wxRect *) 0 ;
5869 wxRect *arg2 = 0 ;
5870 wxRect result;
5871 wxRect temp2 ;
5872 PyObject * obj0 = 0 ;
5873 PyObject * obj1 = 0 ;
5874 char *kwnames[] = {
5875 (char *) "self",(char *) "rect", NULL
5876 };
5877
5878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5880 if (SWIG_arg_fail(1)) SWIG_fail;
5881 {
5882 arg2 = &temp2;
5883 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5884 }
5885 {
5886 PyThreadState* __tstate = wxPyBeginAllowThreads();
5887 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5888
5889 wxPyEndAllowThreads(__tstate);
5890 if (PyErr_Occurred()) SWIG_fail;
5891 }
5892 {
5893 wxRect * resultptr;
5894 resultptr = new wxRect((wxRect &)(result));
5895 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5896 }
5897 return resultobj;
5898 fail:
5899 return NULL;
5900 }
5901
5902
5903 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5904 PyObject *resultobj;
5905 wxRect *arg1 = (wxRect *) 0 ;
5906 wxRect *arg2 = 0 ;
5907 wxRect *result;
5908 wxRect temp2 ;
5909 PyObject * obj0 = 0 ;
5910 PyObject * obj1 = 0 ;
5911 char *kwnames[] = {
5912 (char *) "self",(char *) "rect", NULL
5913 };
5914
5915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5917 if (SWIG_arg_fail(1)) SWIG_fail;
5918 {
5919 arg2 = &temp2;
5920 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5921 }
5922 {
5923 PyThreadState* __tstate = wxPyBeginAllowThreads();
5924 {
5925 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5926 result = (wxRect *) &_result_ref;
5927 }
5928
5929 wxPyEndAllowThreads(__tstate);
5930 if (PyErr_Occurred()) SWIG_fail;
5931 }
5932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5933 return resultobj;
5934 fail:
5935 return NULL;
5936 }
5937
5938
5939 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5940 PyObject *resultobj;
5941 wxRect *arg1 = (wxRect *) 0 ;
5942 wxRect *arg2 = 0 ;
5943 bool result;
5944 wxRect temp2 ;
5945 PyObject * obj0 = 0 ;
5946 PyObject * obj1 = 0 ;
5947 char *kwnames[] = {
5948 (char *) "self",(char *) "rect", NULL
5949 };
5950
5951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5953 if (SWIG_arg_fail(1)) SWIG_fail;
5954 {
5955 arg2 = &temp2;
5956 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5957 }
5958 {
5959 PyThreadState* __tstate = wxPyBeginAllowThreads();
5960 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5961
5962 wxPyEndAllowThreads(__tstate);
5963 if (PyErr_Occurred()) SWIG_fail;
5964 }
5965 {
5966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5967 }
5968 return resultobj;
5969 fail:
5970 return NULL;
5971 }
5972
5973
5974 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5975 PyObject *resultobj;
5976 wxRect *arg1 = (wxRect *) 0 ;
5977 wxRect *arg2 = 0 ;
5978 bool result;
5979 wxRect temp2 ;
5980 PyObject * obj0 = 0 ;
5981 PyObject * obj1 = 0 ;
5982 char *kwnames[] = {
5983 (char *) "self",(char *) "rect", NULL
5984 };
5985
5986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5988 if (SWIG_arg_fail(1)) SWIG_fail;
5989 {
5990 arg2 = &temp2;
5991 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5992 }
5993 {
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5996
5997 wxPyEndAllowThreads(__tstate);
5998 if (PyErr_Occurred()) SWIG_fail;
5999 }
6000 {
6001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6002 }
6003 return resultobj;
6004 fail:
6005 return NULL;
6006 }
6007
6008
6009 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj;
6011 wxRect *arg1 = (wxRect *) 0 ;
6012 int arg2 ;
6013 int arg3 ;
6014 bool result;
6015 PyObject * obj0 = 0 ;
6016 PyObject * obj1 = 0 ;
6017 PyObject * obj2 = 0 ;
6018 char *kwnames[] = {
6019 (char *) "self",(char *) "x",(char *) "y", NULL
6020 };
6021
6022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6024 if (SWIG_arg_fail(1)) SWIG_fail;
6025 {
6026 arg2 = (int)(SWIG_As_int(obj1));
6027 if (SWIG_arg_fail(2)) SWIG_fail;
6028 }
6029 {
6030 arg3 = (int)(SWIG_As_int(obj2));
6031 if (SWIG_arg_fail(3)) SWIG_fail;
6032 }
6033 {
6034 PyThreadState* __tstate = wxPyBeginAllowThreads();
6035 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6036
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 {
6041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6042 }
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6050 PyObject *resultobj;
6051 wxRect *arg1 = (wxRect *) 0 ;
6052 wxPoint *arg2 = 0 ;
6053 bool result;
6054 wxPoint temp2 ;
6055 PyObject * obj0 = 0 ;
6056 PyObject * obj1 = 0 ;
6057 char *kwnames[] = {
6058 (char *) "self",(char *) "pt", NULL
6059 };
6060
6061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6063 if (SWIG_arg_fail(1)) SWIG_fail;
6064 {
6065 arg2 = &temp2;
6066 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6067 }
6068 {
6069 PyThreadState* __tstate = wxPyBeginAllowThreads();
6070 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6071
6072 wxPyEndAllowThreads(__tstate);
6073 if (PyErr_Occurred()) SWIG_fail;
6074 }
6075 {
6076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6077 }
6078 return resultobj;
6079 fail:
6080 return NULL;
6081 }
6082
6083
6084 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj;
6086 wxRect *arg1 = (wxRect *) 0 ;
6087 wxRect *arg2 = 0 ;
6088 bool result;
6089 wxRect temp2 ;
6090 PyObject * obj0 = 0 ;
6091 PyObject * obj1 = 0 ;
6092 char *kwnames[] = {
6093 (char *) "self",(char *) "rect", NULL
6094 };
6095
6096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6098 if (SWIG_arg_fail(1)) SWIG_fail;
6099 {
6100 arg2 = &temp2;
6101 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6102 }
6103 {
6104 PyThreadState* __tstate = wxPyBeginAllowThreads();
6105 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6106
6107 wxPyEndAllowThreads(__tstate);
6108 if (PyErr_Occurred()) SWIG_fail;
6109 }
6110 {
6111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6112 }
6113 return resultobj;
6114 fail:
6115 return NULL;
6116 }
6117
6118
6119 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6120 PyObject *resultobj;
6121 wxRect *arg1 = (wxRect *) 0 ;
6122 int arg2 ;
6123 PyObject * obj0 = 0 ;
6124 PyObject * obj1 = 0 ;
6125 char *kwnames[] = {
6126 (char *) "self",(char *) "x", NULL
6127 };
6128
6129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6131 if (SWIG_arg_fail(1)) SWIG_fail;
6132 {
6133 arg2 = (int)(SWIG_As_int(obj1));
6134 if (SWIG_arg_fail(2)) SWIG_fail;
6135 }
6136 if (arg1) (arg1)->x = arg2;
6137
6138 Py_INCREF(Py_None); resultobj = Py_None;
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj;
6147 wxRect *arg1 = (wxRect *) 0 ;
6148 int result;
6149 PyObject * obj0 = 0 ;
6150 char *kwnames[] = {
6151 (char *) "self", NULL
6152 };
6153
6154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6156 if (SWIG_arg_fail(1)) SWIG_fail;
6157 result = (int) ((arg1)->x);
6158
6159 {
6160 resultobj = SWIG_From_int((int)(result));
6161 }
6162 return resultobj;
6163 fail:
6164 return NULL;
6165 }
6166
6167
6168 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj;
6170 wxRect *arg1 = (wxRect *) 0 ;
6171 int arg2 ;
6172 PyObject * obj0 = 0 ;
6173 PyObject * obj1 = 0 ;
6174 char *kwnames[] = {
6175 (char *) "self",(char *) "y", NULL
6176 };
6177
6178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6180 if (SWIG_arg_fail(1)) SWIG_fail;
6181 {
6182 arg2 = (int)(SWIG_As_int(obj1));
6183 if (SWIG_arg_fail(2)) SWIG_fail;
6184 }
6185 if (arg1) (arg1)->y = arg2;
6186
6187 Py_INCREF(Py_None); resultobj = Py_None;
6188 return resultobj;
6189 fail:
6190 return NULL;
6191 }
6192
6193
6194 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6195 PyObject *resultobj;
6196 wxRect *arg1 = (wxRect *) 0 ;
6197 int result;
6198 PyObject * obj0 = 0 ;
6199 char *kwnames[] = {
6200 (char *) "self", NULL
6201 };
6202
6203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6205 if (SWIG_arg_fail(1)) SWIG_fail;
6206 result = (int) ((arg1)->y);
6207
6208 {
6209 resultobj = SWIG_From_int((int)(result));
6210 }
6211 return resultobj;
6212 fail:
6213 return NULL;
6214 }
6215
6216
6217 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6218 PyObject *resultobj;
6219 wxRect *arg1 = (wxRect *) 0 ;
6220 int arg2 ;
6221 PyObject * obj0 = 0 ;
6222 PyObject * obj1 = 0 ;
6223 char *kwnames[] = {
6224 (char *) "self",(char *) "width", NULL
6225 };
6226
6227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6229 if (SWIG_arg_fail(1)) SWIG_fail;
6230 {
6231 arg2 = (int)(SWIG_As_int(obj1));
6232 if (SWIG_arg_fail(2)) SWIG_fail;
6233 }
6234 if (arg1) (arg1)->width = arg2;
6235
6236 Py_INCREF(Py_None); resultobj = Py_None;
6237 return resultobj;
6238 fail:
6239 return NULL;
6240 }
6241
6242
6243 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6244 PyObject *resultobj;
6245 wxRect *arg1 = (wxRect *) 0 ;
6246 int result;
6247 PyObject * obj0 = 0 ;
6248 char *kwnames[] = {
6249 (char *) "self", NULL
6250 };
6251
6252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6254 if (SWIG_arg_fail(1)) SWIG_fail;
6255 result = (int) ((arg1)->width);
6256
6257 {
6258 resultobj = SWIG_From_int((int)(result));
6259 }
6260 return resultobj;
6261 fail:
6262 return NULL;
6263 }
6264
6265
6266 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6267 PyObject *resultobj;
6268 wxRect *arg1 = (wxRect *) 0 ;
6269 int arg2 ;
6270 PyObject * obj0 = 0 ;
6271 PyObject * obj1 = 0 ;
6272 char *kwnames[] = {
6273 (char *) "self",(char *) "height", NULL
6274 };
6275
6276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6278 if (SWIG_arg_fail(1)) SWIG_fail;
6279 {
6280 arg2 = (int)(SWIG_As_int(obj1));
6281 if (SWIG_arg_fail(2)) SWIG_fail;
6282 }
6283 if (arg1) (arg1)->height = arg2;
6284
6285 Py_INCREF(Py_None); resultobj = Py_None;
6286 return resultobj;
6287 fail:
6288 return NULL;
6289 }
6290
6291
6292 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6293 PyObject *resultobj;
6294 wxRect *arg1 = (wxRect *) 0 ;
6295 int result;
6296 PyObject * obj0 = 0 ;
6297 char *kwnames[] = {
6298 (char *) "self", NULL
6299 };
6300
6301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6303 if (SWIG_arg_fail(1)) SWIG_fail;
6304 result = (int) ((arg1)->height);
6305
6306 {
6307 resultobj = SWIG_From_int((int)(result));
6308 }
6309 return resultobj;
6310 fail:
6311 return NULL;
6312 }
6313
6314
6315 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6316 PyObject *resultobj;
6317 wxRect *arg1 = (wxRect *) 0 ;
6318 int arg2 = (int) 0 ;
6319 int arg3 = (int) 0 ;
6320 int arg4 = (int) 0 ;
6321 int arg5 = (int) 0 ;
6322 PyObject * obj0 = 0 ;
6323 PyObject * obj1 = 0 ;
6324 PyObject * obj2 = 0 ;
6325 PyObject * obj3 = 0 ;
6326 PyObject * obj4 = 0 ;
6327 char *kwnames[] = {
6328 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6329 };
6330
6331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6333 if (SWIG_arg_fail(1)) SWIG_fail;
6334 if (obj1) {
6335 {
6336 arg2 = (int)(SWIG_As_int(obj1));
6337 if (SWIG_arg_fail(2)) SWIG_fail;
6338 }
6339 }
6340 if (obj2) {
6341 {
6342 arg3 = (int)(SWIG_As_int(obj2));
6343 if (SWIG_arg_fail(3)) SWIG_fail;
6344 }
6345 }
6346 if (obj3) {
6347 {
6348 arg4 = (int)(SWIG_As_int(obj3));
6349 if (SWIG_arg_fail(4)) SWIG_fail;
6350 }
6351 }
6352 if (obj4) {
6353 {
6354 arg5 = (int)(SWIG_As_int(obj4));
6355 if (SWIG_arg_fail(5)) SWIG_fail;
6356 }
6357 }
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6361
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 Py_INCREF(Py_None); resultobj = Py_None;
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 PyObject *result;
6376 PyObject * obj0 = 0 ;
6377 char *kwnames[] = {
6378 (char *) "self", NULL
6379 };
6380
6381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6383 if (SWIG_arg_fail(1)) SWIG_fail;
6384 {
6385 PyThreadState* __tstate = wxPyBeginAllowThreads();
6386 result = (PyObject *)wxRect_Get(arg1);
6387
6388 wxPyEndAllowThreads(__tstate);
6389 if (PyErr_Occurred()) SWIG_fail;
6390 }
6391 resultobj = result;
6392 return resultobj;
6393 fail:
6394 return NULL;
6395 }
6396
6397
6398 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6399 PyObject *obj;
6400 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6401 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6402 Py_INCREF(obj);
6403 return Py_BuildValue((char *)"");
6404 }
6405 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6406 PyObject *resultobj;
6407 wxRect *arg1 = (wxRect *) 0 ;
6408 wxRect *arg2 = (wxRect *) 0 ;
6409 PyObject *result;
6410 PyObject * obj0 = 0 ;
6411 PyObject * obj1 = 0 ;
6412 char *kwnames[] = {
6413 (char *) "r1",(char *) "r2", NULL
6414 };
6415
6416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6418 if (SWIG_arg_fail(1)) SWIG_fail;
6419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6420 if (SWIG_arg_fail(2)) SWIG_fail;
6421 {
6422 if (!wxPyCheckForApp()) SWIG_fail;
6423 PyThreadState* __tstate = wxPyBeginAllowThreads();
6424 result = (PyObject *)wxIntersectRect(arg1,arg2);
6425
6426 wxPyEndAllowThreads(__tstate);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 resultobj = result;
6430 return resultobj;
6431 fail:
6432 return NULL;
6433 }
6434
6435
6436 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6437 PyObject *resultobj;
6438 double arg1 = (double) 0.0 ;
6439 double arg2 = (double) 0.0 ;
6440 wxPoint2D *result;
6441 PyObject * obj0 = 0 ;
6442 PyObject * obj1 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "x",(char *) "y", NULL
6445 };
6446
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6448 if (obj0) {
6449 {
6450 arg1 = (double)(SWIG_As_double(obj0));
6451 if (SWIG_arg_fail(1)) SWIG_fail;
6452 }
6453 }
6454 if (obj1) {
6455 {
6456 arg2 = (double)(SWIG_As_double(obj1));
6457 if (SWIG_arg_fail(2)) SWIG_fail;
6458 }
6459 }
6460 {
6461 PyThreadState* __tstate = wxPyBeginAllowThreads();
6462 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6463
6464 wxPyEndAllowThreads(__tstate);
6465 if (PyErr_Occurred()) SWIG_fail;
6466 }
6467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6468 return resultobj;
6469 fail:
6470 return NULL;
6471 }
6472
6473
6474 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6475 PyObject *resultobj;
6476 wxPoint2D *arg1 = 0 ;
6477 wxPoint2D *result;
6478 wxPoint2D temp1 ;
6479 PyObject * obj0 = 0 ;
6480 char *kwnames[] = {
6481 (char *) "pt", NULL
6482 };
6483
6484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6485 {
6486 arg1 = &temp1;
6487 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6488 }
6489 {
6490 PyThreadState* __tstate = wxPyBeginAllowThreads();
6491 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6492
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj;
6505 wxPoint *arg1 = 0 ;
6506 wxPoint2D *result;
6507 wxPoint temp1 ;
6508 PyObject * obj0 = 0 ;
6509 char *kwnames[] = {
6510 (char *) "pt", NULL
6511 };
6512
6513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6514 {
6515 arg1 = &temp1;
6516 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6517 }
6518 {
6519 PyThreadState* __tstate = wxPyBeginAllowThreads();
6520 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6521
6522 wxPyEndAllowThreads(__tstate);
6523 if (PyErr_Occurred()) SWIG_fail;
6524 }
6525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6526 return resultobj;
6527 fail:
6528 return NULL;
6529 }
6530
6531
6532 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6533 PyObject *resultobj;
6534 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6535 int *arg2 = (int *) 0 ;
6536 int *arg3 = (int *) 0 ;
6537 int temp2 ;
6538 int res2 = 0 ;
6539 int temp3 ;
6540 int res3 = 0 ;
6541 PyObject * obj0 = 0 ;
6542 char *kwnames[] = {
6543 (char *) "self", NULL
6544 };
6545
6546 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6547 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6550 if (SWIG_arg_fail(1)) SWIG_fail;
6551 {
6552 PyThreadState* __tstate = wxPyBeginAllowThreads();
6553 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6554
6555 wxPyEndAllowThreads(__tstate);
6556 if (PyErr_Occurred()) SWIG_fail;
6557 }
6558 Py_INCREF(Py_None); resultobj = Py_None;
6559 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6560 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6561 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6562 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj;
6571 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6572 int *arg2 = (int *) 0 ;
6573 int *arg3 = (int *) 0 ;
6574 int temp2 ;
6575 int res2 = 0 ;
6576 int temp3 ;
6577 int res3 = 0 ;
6578 PyObject * obj0 = 0 ;
6579 char *kwnames[] = {
6580 (char *) "self", NULL
6581 };
6582
6583 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6584 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6587 if (SWIG_arg_fail(1)) SWIG_fail;
6588 {
6589 PyThreadState* __tstate = wxPyBeginAllowThreads();
6590 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6591
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 Py_INCREF(Py_None); resultobj = Py_None;
6596 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6597 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6598 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6599 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6607 PyObject *resultobj;
6608 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6609 double result;
6610 PyObject * obj0 = 0 ;
6611 char *kwnames[] = {
6612 (char *) "self", NULL
6613 };
6614
6615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6617 if (SWIG_arg_fail(1)) SWIG_fail;
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6621
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 {
6626 resultobj = SWIG_From_double((double)(result));
6627 }
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj;
6636 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6637 double result;
6638 PyObject * obj0 = 0 ;
6639 char *kwnames[] = {
6640 (char *) "self", NULL
6641 };
6642
6643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6645 if (SWIG_arg_fail(1)) SWIG_fail;
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6649
6650 wxPyEndAllowThreads(__tstate);
6651 if (PyErr_Occurred()) SWIG_fail;
6652 }
6653 {
6654 resultobj = SWIG_From_double((double)(result));
6655 }
6656 return resultobj;
6657 fail:
6658 return NULL;
6659 }
6660
6661
6662 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6663 PyObject *resultobj;
6664 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6665 double arg2 ;
6666 PyObject * obj0 = 0 ;
6667 PyObject * obj1 = 0 ;
6668 char *kwnames[] = {
6669 (char *) "self",(char *) "length", NULL
6670 };
6671
6672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6674 if (SWIG_arg_fail(1)) SWIG_fail;
6675 {
6676 arg2 = (double)(SWIG_As_double(obj1));
6677 if (SWIG_arg_fail(2)) SWIG_fail;
6678 }
6679 {
6680 PyThreadState* __tstate = wxPyBeginAllowThreads();
6681 (arg1)->SetVectorLength(arg2);
6682
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 Py_INCREF(Py_None); resultobj = Py_None;
6687 return resultobj;
6688 fail:
6689 return NULL;
6690 }
6691
6692
6693 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6694 PyObject *resultobj;
6695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6696 double arg2 ;
6697 PyObject * obj0 = 0 ;
6698 PyObject * obj1 = 0 ;
6699 char *kwnames[] = {
6700 (char *) "self",(char *) "degrees", NULL
6701 };
6702
6703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6705 if (SWIG_arg_fail(1)) SWIG_fail;
6706 {
6707 arg2 = (double)(SWIG_As_double(obj1));
6708 if (SWIG_arg_fail(2)) SWIG_fail;
6709 }
6710 {
6711 PyThreadState* __tstate = wxPyBeginAllowThreads();
6712 (arg1)->SetVectorAngle(arg2);
6713
6714 wxPyEndAllowThreads(__tstate);
6715 if (PyErr_Occurred()) SWIG_fail;
6716 }
6717 Py_INCREF(Py_None); resultobj = Py_None;
6718 return resultobj;
6719 fail:
6720 return NULL;
6721 }
6722
6723
6724 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6725 PyObject *resultobj;
6726 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6727 wxPoint2D *arg2 = 0 ;
6728 double result;
6729 wxPoint2D temp2 ;
6730 PyObject * obj0 = 0 ;
6731 PyObject * obj1 = 0 ;
6732 char *kwnames[] = {
6733 (char *) "self",(char *) "pt", NULL
6734 };
6735
6736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6738 if (SWIG_arg_fail(1)) SWIG_fail;
6739 {
6740 arg2 = &temp2;
6741 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6742 }
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6746
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 {
6751 resultobj = SWIG_From_double((double)(result));
6752 }
6753 return resultobj;
6754 fail:
6755 return NULL;
6756 }
6757
6758
6759 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6760 PyObject *resultobj;
6761 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6762 wxPoint2D *arg2 = 0 ;
6763 double result;
6764 wxPoint2D temp2 ;
6765 PyObject * obj0 = 0 ;
6766 PyObject * obj1 = 0 ;
6767 char *kwnames[] = {
6768 (char *) "self",(char *) "pt", NULL
6769 };
6770
6771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6773 if (SWIG_arg_fail(1)) SWIG_fail;
6774 {
6775 arg2 = &temp2;
6776 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6777 }
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6781
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 {
6786 resultobj = SWIG_From_double((double)(result));
6787 }
6788 return resultobj;
6789 fail:
6790 return NULL;
6791 }
6792
6793
6794 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6795 PyObject *resultobj;
6796 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6797 wxPoint2D *arg2 = 0 ;
6798 double result;
6799 wxPoint2D temp2 ;
6800 PyObject * obj0 = 0 ;
6801 PyObject * obj1 = 0 ;
6802 char *kwnames[] = {
6803 (char *) "self",(char *) "vec", NULL
6804 };
6805
6806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6808 if (SWIG_arg_fail(1)) SWIG_fail;
6809 {
6810 arg2 = &temp2;
6811 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6812 }
6813 {
6814 PyThreadState* __tstate = wxPyBeginAllowThreads();
6815 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6816
6817 wxPyEndAllowThreads(__tstate);
6818 if (PyErr_Occurred()) SWIG_fail;
6819 }
6820 {
6821 resultobj = SWIG_From_double((double)(result));
6822 }
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6830 PyObject *resultobj;
6831 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6832 wxPoint2D *arg2 = 0 ;
6833 double result;
6834 wxPoint2D temp2 ;
6835 PyObject * obj0 = 0 ;
6836 PyObject * obj1 = 0 ;
6837 char *kwnames[] = {
6838 (char *) "self",(char *) "vec", NULL
6839 };
6840
6841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6843 if (SWIG_arg_fail(1)) SWIG_fail;
6844 {
6845 arg2 = &temp2;
6846 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6847 }
6848 {
6849 PyThreadState* __tstate = wxPyBeginAllowThreads();
6850 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6851
6852 wxPyEndAllowThreads(__tstate);
6853 if (PyErr_Occurred()) SWIG_fail;
6854 }
6855 {
6856 resultobj = SWIG_From_double((double)(result));
6857 }
6858 return resultobj;
6859 fail:
6860 return NULL;
6861 }
6862
6863
6864 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6865 PyObject *resultobj;
6866 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6867 wxPoint2D result;
6868 PyObject * obj0 = 0 ;
6869 char *kwnames[] = {
6870 (char *) "self", NULL
6871 };
6872
6873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6875 if (SWIG_arg_fail(1)) SWIG_fail;
6876 {
6877 PyThreadState* __tstate = wxPyBeginAllowThreads();
6878 result = (arg1)->operator -();
6879
6880 wxPyEndAllowThreads(__tstate);
6881 if (PyErr_Occurred()) SWIG_fail;
6882 }
6883 {
6884 wxPoint2D * resultptr;
6885 resultptr = new wxPoint2D((wxPoint2D &)(result));
6886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6887 }
6888 return resultobj;
6889 fail:
6890 return NULL;
6891 }
6892
6893
6894 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6895 PyObject *resultobj;
6896 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6897 wxPoint2D *arg2 = 0 ;
6898 wxPoint2D *result;
6899 wxPoint2D temp2 ;
6900 PyObject * obj0 = 0 ;
6901 PyObject * obj1 = 0 ;
6902 char *kwnames[] = {
6903 (char *) "self",(char *) "pt", NULL
6904 };
6905
6906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6908 if (SWIG_arg_fail(1)) SWIG_fail;
6909 {
6910 arg2 = &temp2;
6911 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6912 }
6913 {
6914 PyThreadState* __tstate = wxPyBeginAllowThreads();
6915 {
6916 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6917 result = (wxPoint2D *) &_result_ref;
6918 }
6919
6920 wxPyEndAllowThreads(__tstate);
6921 if (PyErr_Occurred()) SWIG_fail;
6922 }
6923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj;
6932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6933 wxPoint2D *arg2 = 0 ;
6934 wxPoint2D *result;
6935 wxPoint2D temp2 ;
6936 PyObject * obj0 = 0 ;
6937 PyObject * obj1 = 0 ;
6938 char *kwnames[] = {
6939 (char *) "self",(char *) "pt", NULL
6940 };
6941
6942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6944 if (SWIG_arg_fail(1)) SWIG_fail;
6945 {
6946 arg2 = &temp2;
6947 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6948 }
6949 {
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 {
6952 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6953 result = (wxPoint2D *) &_result_ref;
6954 }
6955
6956 wxPyEndAllowThreads(__tstate);
6957 if (PyErr_Occurred()) SWIG_fail;
6958 }
6959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6960 return resultobj;
6961 fail:
6962 return NULL;
6963 }
6964
6965
6966 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6967 PyObject *resultobj;
6968 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6969 wxPoint2D *arg2 = 0 ;
6970 wxPoint2D *result;
6971 wxPoint2D temp2 ;
6972 PyObject * obj0 = 0 ;
6973 PyObject * obj1 = 0 ;
6974 char *kwnames[] = {
6975 (char *) "self",(char *) "pt", NULL
6976 };
6977
6978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6980 if (SWIG_arg_fail(1)) SWIG_fail;
6981 {
6982 arg2 = &temp2;
6983 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6984 }
6985 {
6986 PyThreadState* __tstate = wxPyBeginAllowThreads();
6987 {
6988 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6989 result = (wxPoint2D *) &_result_ref;
6990 }
6991
6992 wxPyEndAllowThreads(__tstate);
6993 if (PyErr_Occurred()) SWIG_fail;
6994 }
6995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6996 return resultobj;
6997 fail:
6998 return NULL;
6999 }
7000
7001
7002 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7003 PyObject *resultobj;
7004 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7005 wxPoint2D *arg2 = 0 ;
7006 wxPoint2D *result;
7007 wxPoint2D temp2 ;
7008 PyObject * obj0 = 0 ;
7009 PyObject * obj1 = 0 ;
7010 char *kwnames[] = {
7011 (char *) "self",(char *) "pt", NULL
7012 };
7013
7014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7016 if (SWIG_arg_fail(1)) SWIG_fail;
7017 {
7018 arg2 = &temp2;
7019 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7020 }
7021 {
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 {
7024 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7025 result = (wxPoint2D *) &_result_ref;
7026 }
7027
7028 wxPyEndAllowThreads(__tstate);
7029 if (PyErr_Occurred()) SWIG_fail;
7030 }
7031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7032 return resultobj;
7033 fail:
7034 return NULL;
7035 }
7036
7037
7038 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7039 PyObject *resultobj;
7040 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7041 wxPoint2D *arg2 = 0 ;
7042 bool result;
7043 wxPoint2D temp2 ;
7044 PyObject * obj0 = 0 ;
7045 PyObject * obj1 = 0 ;
7046 char *kwnames[] = {
7047 (char *) "self",(char *) "pt", NULL
7048 };
7049
7050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7052 if (SWIG_arg_fail(1)) SWIG_fail;
7053 {
7054 arg2 = &temp2;
7055 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7056 }
7057 {
7058 PyThreadState* __tstate = wxPyBeginAllowThreads();
7059 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7060
7061 wxPyEndAllowThreads(__tstate);
7062 if (PyErr_Occurred()) SWIG_fail;
7063 }
7064 {
7065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7066 }
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj;
7075 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7076 wxPoint2D *arg2 = 0 ;
7077 bool result;
7078 wxPoint2D temp2 ;
7079 PyObject * obj0 = 0 ;
7080 PyObject * obj1 = 0 ;
7081 char *kwnames[] = {
7082 (char *) "self",(char *) "pt", NULL
7083 };
7084
7085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7087 if (SWIG_arg_fail(1)) SWIG_fail;
7088 {
7089 arg2 = &temp2;
7090 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7091 }
7092 {
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7095
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 {
7100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7101 }
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7109 PyObject *resultobj;
7110 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7111 double arg2 ;
7112 PyObject * obj0 = 0 ;
7113 PyObject * obj1 = 0 ;
7114 char *kwnames[] = {
7115 (char *) "self",(char *) "m_x", NULL
7116 };
7117
7118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7120 if (SWIG_arg_fail(1)) SWIG_fail;
7121 {
7122 arg2 = (double)(SWIG_As_double(obj1));
7123 if (SWIG_arg_fail(2)) SWIG_fail;
7124 }
7125 if (arg1) (arg1)->m_x = arg2;
7126
7127 Py_INCREF(Py_None); resultobj = Py_None;
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7135 PyObject *resultobj;
7136 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7137 double result;
7138 PyObject * obj0 = 0 ;
7139 char *kwnames[] = {
7140 (char *) "self", NULL
7141 };
7142
7143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7145 if (SWIG_arg_fail(1)) SWIG_fail;
7146 result = (double) ((arg1)->m_x);
7147
7148 {
7149 resultobj = SWIG_From_double((double)(result));
7150 }
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj;
7159 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7160 double arg2 ;
7161 PyObject * obj0 = 0 ;
7162 PyObject * obj1 = 0 ;
7163 char *kwnames[] = {
7164 (char *) "self",(char *) "m_y", NULL
7165 };
7166
7167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7169 if (SWIG_arg_fail(1)) SWIG_fail;
7170 {
7171 arg2 = (double)(SWIG_As_double(obj1));
7172 if (SWIG_arg_fail(2)) SWIG_fail;
7173 }
7174 if (arg1) (arg1)->m_y = arg2;
7175
7176 Py_INCREF(Py_None); resultobj = Py_None;
7177 return resultobj;
7178 fail:
7179 return NULL;
7180 }
7181
7182
7183 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7184 PyObject *resultobj;
7185 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7186 double result;
7187 PyObject * obj0 = 0 ;
7188 char *kwnames[] = {
7189 (char *) "self", NULL
7190 };
7191
7192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7194 if (SWIG_arg_fail(1)) SWIG_fail;
7195 result = (double) ((arg1)->m_y);
7196
7197 {
7198 resultobj = SWIG_From_double((double)(result));
7199 }
7200 return resultobj;
7201 fail:
7202 return NULL;
7203 }
7204
7205
7206 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7207 PyObject *resultobj;
7208 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7209 double arg2 = (double) 0 ;
7210 double arg3 = (double) 0 ;
7211 PyObject * obj0 = 0 ;
7212 PyObject * obj1 = 0 ;
7213 PyObject * obj2 = 0 ;
7214 char *kwnames[] = {
7215 (char *) "self",(char *) "x",(char *) "y", NULL
7216 };
7217
7218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7220 if (SWIG_arg_fail(1)) SWIG_fail;
7221 if (obj1) {
7222 {
7223 arg2 = (double)(SWIG_As_double(obj1));
7224 if (SWIG_arg_fail(2)) SWIG_fail;
7225 }
7226 }
7227 if (obj2) {
7228 {
7229 arg3 = (double)(SWIG_As_double(obj2));
7230 if (SWIG_arg_fail(3)) SWIG_fail;
7231 }
7232 }
7233 {
7234 PyThreadState* __tstate = wxPyBeginAllowThreads();
7235 wxPoint2D_Set(arg1,arg2,arg3);
7236
7237 wxPyEndAllowThreads(__tstate);
7238 if (PyErr_Occurred()) SWIG_fail;
7239 }
7240 Py_INCREF(Py_None); resultobj = Py_None;
7241 return resultobj;
7242 fail:
7243 return NULL;
7244 }
7245
7246
7247 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7248 PyObject *resultobj;
7249 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7250 PyObject *result;
7251 PyObject * obj0 = 0 ;
7252 char *kwnames[] = {
7253 (char *) "self", NULL
7254 };
7255
7256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7258 if (SWIG_arg_fail(1)) SWIG_fail;
7259 {
7260 PyThreadState* __tstate = wxPyBeginAllowThreads();
7261 result = (PyObject *)wxPoint2D_Get(arg1);
7262
7263 wxPyEndAllowThreads(__tstate);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 resultobj = result;
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7274 PyObject *obj;
7275 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7276 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7277 Py_INCREF(obj);
7278 return Py_BuildValue((char *)"");
7279 }
7280 static int _wrap_DefaultPosition_set(PyObject *) {
7281 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7282 return 1;
7283 }
7284
7285
7286 static PyObject *_wrap_DefaultPosition_get(void) {
7287 PyObject *pyobj;
7288
7289 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7290 return pyobj;
7291 }
7292
7293
7294 static int _wrap_DefaultSize_set(PyObject *) {
7295 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7296 return 1;
7297 }
7298
7299
7300 static PyObject *_wrap_DefaultSize_get(void) {
7301 PyObject *pyobj;
7302
7303 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7304 return pyobj;
7305 }
7306
7307
7308 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7309 PyObject *resultobj;
7310 PyObject *arg1 = (PyObject *) 0 ;
7311 wxPyInputStream *result;
7312 PyObject * obj0 = 0 ;
7313 char *kwnames[] = {
7314 (char *) "p", NULL
7315 };
7316
7317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7318 arg1 = obj0;
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7322
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7327 return resultobj;
7328 fail:
7329 return NULL;
7330 }
7331
7332
7333 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7334 PyObject *resultobj;
7335 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7336 PyObject * obj0 = 0 ;
7337 char *kwnames[] = {
7338 (char *) "self", NULL
7339 };
7340
7341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7343 if (SWIG_arg_fail(1)) SWIG_fail;
7344 {
7345 PyThreadState* __tstate = wxPyBeginAllowThreads();
7346 delete arg1;
7347
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 Py_INCREF(Py_None); resultobj = Py_None;
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7359 PyObject *resultobj;
7360 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7361 PyObject * obj0 = 0 ;
7362 char *kwnames[] = {
7363 (char *) "self", NULL
7364 };
7365
7366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7368 if (SWIG_arg_fail(1)) SWIG_fail;
7369 {
7370 PyThreadState* __tstate = wxPyBeginAllowThreads();
7371 (arg1)->close();
7372
7373 wxPyEndAllowThreads(__tstate);
7374 if (PyErr_Occurred()) SWIG_fail;
7375 }
7376 Py_INCREF(Py_None); resultobj = Py_None;
7377 return resultobj;
7378 fail:
7379 return NULL;
7380 }
7381
7382
7383 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7384 PyObject *resultobj;
7385 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7386 PyObject * obj0 = 0 ;
7387 char *kwnames[] = {
7388 (char *) "self", NULL
7389 };
7390
7391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7393 if (SWIG_arg_fail(1)) SWIG_fail;
7394 {
7395 PyThreadState* __tstate = wxPyBeginAllowThreads();
7396 (arg1)->flush();
7397
7398 wxPyEndAllowThreads(__tstate);
7399 if (PyErr_Occurred()) SWIG_fail;
7400 }
7401 Py_INCREF(Py_None); resultobj = Py_None;
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7409 PyObject *resultobj;
7410 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7411 bool result;
7412 PyObject * obj0 = 0 ;
7413 char *kwnames[] = {
7414 (char *) "self", NULL
7415 };
7416
7417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7419 if (SWIG_arg_fail(1)) SWIG_fail;
7420 {
7421 PyThreadState* __tstate = wxPyBeginAllowThreads();
7422 result = (bool)(arg1)->eof();
7423
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 {
7428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7429 }
7430 return resultobj;
7431 fail:
7432 return NULL;
7433 }
7434
7435
7436 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7437 PyObject *resultobj;
7438 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7439 int arg2 = (int) -1 ;
7440 PyObject *result;
7441 PyObject * obj0 = 0 ;
7442 PyObject * obj1 = 0 ;
7443 char *kwnames[] = {
7444 (char *) "self",(char *) "size", NULL
7445 };
7446
7447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7449 if (SWIG_arg_fail(1)) SWIG_fail;
7450 if (obj1) {
7451 {
7452 arg2 = (int)(SWIG_As_int(obj1));
7453 if (SWIG_arg_fail(2)) SWIG_fail;
7454 }
7455 }
7456 {
7457 PyThreadState* __tstate = wxPyBeginAllowThreads();
7458 result = (PyObject *)(arg1)->read(arg2);
7459
7460 wxPyEndAllowThreads(__tstate);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 resultobj = result;
7464 return resultobj;
7465 fail:
7466 return NULL;
7467 }
7468
7469
7470 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7471 PyObject *resultobj;
7472 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7473 int arg2 = (int) -1 ;
7474 PyObject *result;
7475 PyObject * obj0 = 0 ;
7476 PyObject * obj1 = 0 ;
7477 char *kwnames[] = {
7478 (char *) "self",(char *) "size", NULL
7479 };
7480
7481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7483 if (SWIG_arg_fail(1)) SWIG_fail;
7484 if (obj1) {
7485 {
7486 arg2 = (int)(SWIG_As_int(obj1));
7487 if (SWIG_arg_fail(2)) SWIG_fail;
7488 }
7489 }
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 result = (PyObject *)(arg1)->readline(arg2);
7493
7494 wxPyEndAllowThreads(__tstate);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 resultobj = result;
7498 return resultobj;
7499 fail:
7500 return NULL;
7501 }
7502
7503
7504 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7505 PyObject *resultobj;
7506 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7507 int arg2 = (int) -1 ;
7508 PyObject *result;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 char *kwnames[] = {
7512 (char *) "self",(char *) "sizehint", NULL
7513 };
7514
7515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7517 if (SWIG_arg_fail(1)) SWIG_fail;
7518 if (obj1) {
7519 {
7520 arg2 = (int)(SWIG_As_int(obj1));
7521 if (SWIG_arg_fail(2)) SWIG_fail;
7522 }
7523 }
7524 {
7525 PyThreadState* __tstate = wxPyBeginAllowThreads();
7526 result = (PyObject *)(arg1)->readlines(arg2);
7527
7528 wxPyEndAllowThreads(__tstate);
7529 if (PyErr_Occurred()) SWIG_fail;
7530 }
7531 resultobj = result;
7532 return resultobj;
7533 fail:
7534 return NULL;
7535 }
7536
7537
7538 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7539 PyObject *resultobj;
7540 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7541 int arg2 ;
7542 int arg3 = (int) 0 ;
7543 PyObject * obj0 = 0 ;
7544 PyObject * obj1 = 0 ;
7545 PyObject * obj2 = 0 ;
7546 char *kwnames[] = {
7547 (char *) "self",(char *) "offset",(char *) "whence", NULL
7548 };
7549
7550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7552 if (SWIG_arg_fail(1)) SWIG_fail;
7553 {
7554 arg2 = (int)(SWIG_As_int(obj1));
7555 if (SWIG_arg_fail(2)) SWIG_fail;
7556 }
7557 if (obj2) {
7558 {
7559 arg3 = (int)(SWIG_As_int(obj2));
7560 if (SWIG_arg_fail(3)) SWIG_fail;
7561 }
7562 }
7563 {
7564 PyThreadState* __tstate = wxPyBeginAllowThreads();
7565 (arg1)->seek(arg2,arg3);
7566
7567 wxPyEndAllowThreads(__tstate);
7568 if (PyErr_Occurred()) SWIG_fail;
7569 }
7570 Py_INCREF(Py_None); resultobj = Py_None;
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7578 PyObject *resultobj;
7579 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7580 int result;
7581 PyObject * obj0 = 0 ;
7582 char *kwnames[] = {
7583 (char *) "self", NULL
7584 };
7585
7586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7588 if (SWIG_arg_fail(1)) SWIG_fail;
7589 {
7590 PyThreadState* __tstate = wxPyBeginAllowThreads();
7591 result = (int)(arg1)->tell();
7592
7593 wxPyEndAllowThreads(__tstate);
7594 if (PyErr_Occurred()) SWIG_fail;
7595 }
7596 {
7597 resultobj = SWIG_From_int((int)(result));
7598 }
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7606 PyObject *resultobj;
7607 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7608 char result;
7609 PyObject * obj0 = 0 ;
7610 char *kwnames[] = {
7611 (char *) "self", NULL
7612 };
7613
7614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7616 if (SWIG_arg_fail(1)) SWIG_fail;
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 result = (char)(arg1)->Peek();
7620
7621 wxPyEndAllowThreads(__tstate);
7622 if (PyErr_Occurred()) SWIG_fail;
7623 }
7624 {
7625 resultobj = SWIG_From_char((char)(result));
7626 }
7627 return resultobj;
7628 fail:
7629 return NULL;
7630 }
7631
7632
7633 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7634 PyObject *resultobj;
7635 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7636 char result;
7637 PyObject * obj0 = 0 ;
7638 char *kwnames[] = {
7639 (char *) "self", NULL
7640 };
7641
7642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7644 if (SWIG_arg_fail(1)) SWIG_fail;
7645 {
7646 PyThreadState* __tstate = wxPyBeginAllowThreads();
7647 result = (char)(arg1)->GetC();
7648
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 {
7653 resultobj = SWIG_From_char((char)(result));
7654 }
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj;
7663 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7664 size_t result;
7665 PyObject * obj0 = 0 ;
7666 char *kwnames[] = {
7667 (char *) "self", NULL
7668 };
7669
7670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7672 if (SWIG_arg_fail(1)) SWIG_fail;
7673 {
7674 PyThreadState* __tstate = wxPyBeginAllowThreads();
7675 result = (size_t)(arg1)->LastRead();
7676
7677 wxPyEndAllowThreads(__tstate);
7678 if (PyErr_Occurred()) SWIG_fail;
7679 }
7680 {
7681 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7682 }
7683 return resultobj;
7684 fail:
7685 return NULL;
7686 }
7687
7688
7689 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7690 PyObject *resultobj;
7691 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7692 bool result;
7693 PyObject * obj0 = 0 ;
7694 char *kwnames[] = {
7695 (char *) "self", NULL
7696 };
7697
7698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7700 if (SWIG_arg_fail(1)) SWIG_fail;
7701 {
7702 PyThreadState* __tstate = wxPyBeginAllowThreads();
7703 result = (bool)(arg1)->CanRead();
7704
7705 wxPyEndAllowThreads(__tstate);
7706 if (PyErr_Occurred()) SWIG_fail;
7707 }
7708 {
7709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7710 }
7711 return resultobj;
7712 fail:
7713 return NULL;
7714 }
7715
7716
7717 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7718 PyObject *resultobj;
7719 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7720 bool result;
7721 PyObject * obj0 = 0 ;
7722 char *kwnames[] = {
7723 (char *) "self", NULL
7724 };
7725
7726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7728 if (SWIG_arg_fail(1)) SWIG_fail;
7729 {
7730 PyThreadState* __tstate = wxPyBeginAllowThreads();
7731 result = (bool)(arg1)->Eof();
7732
7733 wxPyEndAllowThreads(__tstate);
7734 if (PyErr_Occurred()) SWIG_fail;
7735 }
7736 {
7737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7738 }
7739 return resultobj;
7740 fail:
7741 return NULL;
7742 }
7743
7744
7745 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7746 PyObject *resultobj;
7747 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7748 char arg2 ;
7749 bool result;
7750 PyObject * obj0 = 0 ;
7751 PyObject * obj1 = 0 ;
7752 char *kwnames[] = {
7753 (char *) "self",(char *) "c", NULL
7754 };
7755
7756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7758 if (SWIG_arg_fail(1)) SWIG_fail;
7759 {
7760 arg2 = (char)(SWIG_As_char(obj1));
7761 if (SWIG_arg_fail(2)) SWIG_fail;
7762 }
7763 {
7764 PyThreadState* __tstate = wxPyBeginAllowThreads();
7765 result = (bool)(arg1)->Ungetch(arg2);
7766
7767 wxPyEndAllowThreads(__tstate);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 {
7771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7772 }
7773 return resultobj;
7774 fail:
7775 return NULL;
7776 }
7777
7778
7779 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7780 PyObject *resultobj;
7781 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7782 long arg2 ;
7783 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7784 long result;
7785 PyObject * obj0 = 0 ;
7786 PyObject * obj1 = 0 ;
7787 PyObject * obj2 = 0 ;
7788 char *kwnames[] = {
7789 (char *) "self",(char *) "pos",(char *) "mode", NULL
7790 };
7791
7792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7794 if (SWIG_arg_fail(1)) SWIG_fail;
7795 {
7796 arg2 = (long)(SWIG_As_long(obj1));
7797 if (SWIG_arg_fail(2)) SWIG_fail;
7798 }
7799 if (obj2) {
7800 {
7801 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7802 if (SWIG_arg_fail(3)) SWIG_fail;
7803 }
7804 }
7805 {
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7808
7809 wxPyEndAllowThreads(__tstate);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 {
7813 resultobj = SWIG_From_long((long)(result));
7814 }
7815 return resultobj;
7816 fail:
7817 return NULL;
7818 }
7819
7820
7821 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7822 PyObject *resultobj;
7823 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7824 long result;
7825 PyObject * obj0 = 0 ;
7826 char *kwnames[] = {
7827 (char *) "self", NULL
7828 };
7829
7830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7832 if (SWIG_arg_fail(1)) SWIG_fail;
7833 {
7834 PyThreadState* __tstate = wxPyBeginAllowThreads();
7835 result = (long)(arg1)->TellI();
7836
7837 wxPyEndAllowThreads(__tstate);
7838 if (PyErr_Occurred()) SWIG_fail;
7839 }
7840 {
7841 resultobj = SWIG_From_long((long)(result));
7842 }
7843 return resultobj;
7844 fail:
7845 return NULL;
7846 }
7847
7848
7849 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7850 PyObject *obj;
7851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7852 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7853 Py_INCREF(obj);
7854 return Py_BuildValue((char *)"");
7855 }
7856 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7857 PyObject *resultobj;
7858 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7859 PyObject *arg2 = (PyObject *) 0 ;
7860 PyObject * obj0 = 0 ;
7861 PyObject * obj1 = 0 ;
7862 char *kwnames[] = {
7863 (char *) "self",(char *) "obj", NULL
7864 };
7865
7866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7868 if (SWIG_arg_fail(1)) SWIG_fail;
7869 arg2 = obj1;
7870 {
7871 PyThreadState* __tstate = wxPyBeginAllowThreads();
7872 wxOutputStream_write(arg1,arg2);
7873
7874 wxPyEndAllowThreads(__tstate);
7875 if (PyErr_Occurred()) SWIG_fail;
7876 }
7877 Py_INCREF(Py_None); resultobj = Py_None;
7878 return resultobj;
7879 fail:
7880 return NULL;
7881 }
7882
7883
7884 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7885 PyObject *obj;
7886 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7887 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7888 Py_INCREF(obj);
7889 return Py_BuildValue((char *)"");
7890 }
7891 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7892 PyObject *resultobj;
7893 wxInputStream *arg1 = (wxInputStream *) 0 ;
7894 wxString *arg2 = 0 ;
7895 wxString *arg3 = 0 ;
7896 wxString *arg4 = 0 ;
7897 wxDateTime arg5 ;
7898 wxFSFile *result;
7899 wxPyInputStream *temp1 ;
7900 bool created1 ;
7901 bool temp2 = false ;
7902 bool temp3 = false ;
7903 bool temp4 = false ;
7904 PyObject * obj0 = 0 ;
7905 PyObject * obj1 = 0 ;
7906 PyObject * obj2 = 0 ;
7907 PyObject * obj3 = 0 ;
7908 PyObject * obj4 = 0 ;
7909 char *kwnames[] = {
7910 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7911 };
7912
7913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7914 {
7915 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7916 arg1 = temp1->m_wxis;
7917 created1 = false;
7918 } else {
7919 PyErr_Clear(); // clear the failure of the wxPyConvert above
7920 arg1 = wxPyCBInputStream_create(obj0, false);
7921 if (arg1 == NULL) {
7922 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7923 SWIG_fail;
7924 }
7925 created1 = true;
7926 }
7927 }
7928 {
7929 arg2 = wxString_in_helper(obj1);
7930 if (arg2 == NULL) SWIG_fail;
7931 temp2 = true;
7932 }
7933 {
7934 arg3 = wxString_in_helper(obj2);
7935 if (arg3 == NULL) SWIG_fail;
7936 temp3 = true;
7937 }
7938 {
7939 arg4 = wxString_in_helper(obj3);
7940 if (arg4 == NULL) SWIG_fail;
7941 temp4 = true;
7942 }
7943 {
7944 wxDateTime * argp;
7945 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7946 if (SWIG_arg_fail(5)) SWIG_fail;
7947 if (argp == NULL) {
7948 SWIG_null_ref("wxDateTime");
7949 }
7950 if (SWIG_arg_fail(5)) SWIG_fail;
7951 arg5 = *argp;
7952 }
7953 {
7954 PyThreadState* __tstate = wxPyBeginAllowThreads();
7955 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7956
7957 wxPyEndAllowThreads(__tstate);
7958 if (PyErr_Occurred()) SWIG_fail;
7959 }
7960 {
7961 resultobj = wxPyMake_wxObject(result, 1);
7962 }
7963 {
7964 if (created1)
7965 delete arg1;
7966 }
7967 {
7968 if (temp2)
7969 delete arg2;
7970 }
7971 {
7972 if (temp3)
7973 delete arg3;
7974 }
7975 {
7976 if (temp4)
7977 delete arg4;
7978 }
7979 return resultobj;
7980 fail:
7981 {
7982 if (created1)
7983 delete arg1;
7984 }
7985 {
7986 if (temp2)
7987 delete arg2;
7988 }
7989 {
7990 if (temp3)
7991 delete arg3;
7992 }
7993 {
7994 if (temp4)
7995 delete arg4;
7996 }
7997 return NULL;
7998 }
7999
8000
8001 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8002 PyObject *resultobj;
8003 wxFSFile *arg1 = (wxFSFile *) 0 ;
8004 PyObject * obj0 = 0 ;
8005 char *kwnames[] = {
8006 (char *) "self", NULL
8007 };
8008
8009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8011 if (SWIG_arg_fail(1)) SWIG_fail;
8012 {
8013 PyThreadState* __tstate = wxPyBeginAllowThreads();
8014 delete arg1;
8015
8016 wxPyEndAllowThreads(__tstate);
8017 if (PyErr_Occurred()) SWIG_fail;
8018 }
8019 Py_INCREF(Py_None); resultobj = Py_None;
8020 return resultobj;
8021 fail:
8022 return NULL;
8023 }
8024
8025
8026 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8027 PyObject *resultobj;
8028 wxFSFile *arg1 = (wxFSFile *) 0 ;
8029 wxInputStream *result;
8030 PyObject * obj0 = 0 ;
8031 char *kwnames[] = {
8032 (char *) "self", NULL
8033 };
8034
8035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8037 if (SWIG_arg_fail(1)) SWIG_fail;
8038 {
8039 PyThreadState* __tstate = wxPyBeginAllowThreads();
8040 result = (wxInputStream *)(arg1)->GetStream();
8041
8042 wxPyEndAllowThreads(__tstate);
8043 if (PyErr_Occurred()) SWIG_fail;
8044 }
8045 {
8046 wxPyInputStream * _ptr = NULL;
8047
8048 if (result) {
8049 _ptr = new wxPyInputStream(result);
8050 }
8051 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8052 }
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8060 PyObject *resultobj;
8061 wxFSFile *arg1 = (wxFSFile *) 0 ;
8062 wxString *result;
8063 PyObject * obj0 = 0 ;
8064 char *kwnames[] = {
8065 (char *) "self", NULL
8066 };
8067
8068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8070 if (SWIG_arg_fail(1)) SWIG_fail;
8071 {
8072 PyThreadState* __tstate = wxPyBeginAllowThreads();
8073 {
8074 wxString const &_result_ref = (arg1)->GetMimeType();
8075 result = (wxString *) &_result_ref;
8076 }
8077
8078 wxPyEndAllowThreads(__tstate);
8079 if (PyErr_Occurred()) SWIG_fail;
8080 }
8081 {
8082 #if wxUSE_UNICODE
8083 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8084 #else
8085 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8086 #endif
8087 }
8088 return resultobj;
8089 fail:
8090 return NULL;
8091 }
8092
8093
8094 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8095 PyObject *resultobj;
8096 wxFSFile *arg1 = (wxFSFile *) 0 ;
8097 wxString *result;
8098 PyObject * obj0 = 0 ;
8099 char *kwnames[] = {
8100 (char *) "self", NULL
8101 };
8102
8103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8105 if (SWIG_arg_fail(1)) SWIG_fail;
8106 {
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 {
8109 wxString const &_result_ref = (arg1)->GetLocation();
8110 result = (wxString *) &_result_ref;
8111 }
8112
8113 wxPyEndAllowThreads(__tstate);
8114 if (PyErr_Occurred()) SWIG_fail;
8115 }
8116 {
8117 #if wxUSE_UNICODE
8118 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8119 #else
8120 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8121 #endif
8122 }
8123 return resultobj;
8124 fail:
8125 return NULL;
8126 }
8127
8128
8129 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8130 PyObject *resultobj;
8131 wxFSFile *arg1 = (wxFSFile *) 0 ;
8132 wxString *result;
8133 PyObject * obj0 = 0 ;
8134 char *kwnames[] = {
8135 (char *) "self", NULL
8136 };
8137
8138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8140 if (SWIG_arg_fail(1)) SWIG_fail;
8141 {
8142 PyThreadState* __tstate = wxPyBeginAllowThreads();
8143 {
8144 wxString const &_result_ref = (arg1)->GetAnchor();
8145 result = (wxString *) &_result_ref;
8146 }
8147
8148 wxPyEndAllowThreads(__tstate);
8149 if (PyErr_Occurred()) SWIG_fail;
8150 }
8151 {
8152 #if wxUSE_UNICODE
8153 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8154 #else
8155 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8156 #endif
8157 }
8158 return resultobj;
8159 fail:
8160 return NULL;
8161 }
8162
8163
8164 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8165 PyObject *resultobj;
8166 wxFSFile *arg1 = (wxFSFile *) 0 ;
8167 wxDateTime result;
8168 PyObject * obj0 = 0 ;
8169 char *kwnames[] = {
8170 (char *) "self", NULL
8171 };
8172
8173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8175 if (SWIG_arg_fail(1)) SWIG_fail;
8176 {
8177 PyThreadState* __tstate = wxPyBeginAllowThreads();
8178 result = (arg1)->GetModificationTime();
8179
8180 wxPyEndAllowThreads(__tstate);
8181 if (PyErr_Occurred()) SWIG_fail;
8182 }
8183 {
8184 wxDateTime * resultptr;
8185 resultptr = new wxDateTime((wxDateTime &)(result));
8186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8187 }
8188 return resultobj;
8189 fail:
8190 return NULL;
8191 }
8192
8193
8194 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8195 PyObject *obj;
8196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8197 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8198 Py_INCREF(obj);
8199 return Py_BuildValue((char *)"");
8200 }
8201 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8202 PyObject *obj;
8203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8204 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8205 Py_INCREF(obj);
8206 return Py_BuildValue((char *)"");
8207 }
8208 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8209 PyObject *resultobj;
8210 wxPyFileSystemHandler *result;
8211 char *kwnames[] = {
8212 NULL
8213 };
8214
8215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8216 {
8217 PyThreadState* __tstate = wxPyBeginAllowThreads();
8218 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8219
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8224 return resultobj;
8225 fail:
8226 return NULL;
8227 }
8228
8229
8230 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8231 PyObject *resultobj;
8232 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8233 PyObject *arg2 = (PyObject *) 0 ;
8234 PyObject *arg3 = (PyObject *) 0 ;
8235 PyObject * obj0 = 0 ;
8236 PyObject * obj1 = 0 ;
8237 PyObject * obj2 = 0 ;
8238 char *kwnames[] = {
8239 (char *) "self",(char *) "self",(char *) "_class", NULL
8240 };
8241
8242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8244 if (SWIG_arg_fail(1)) SWIG_fail;
8245 arg2 = obj1;
8246 arg3 = obj2;
8247 {
8248 PyThreadState* __tstate = wxPyBeginAllowThreads();
8249 (arg1)->_setCallbackInfo(arg2,arg3);
8250
8251 wxPyEndAllowThreads(__tstate);
8252 if (PyErr_Occurred()) SWIG_fail;
8253 }
8254 Py_INCREF(Py_None); resultobj = Py_None;
8255 return resultobj;
8256 fail:
8257 return NULL;
8258 }
8259
8260
8261 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8262 PyObject *resultobj;
8263 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8264 wxString *arg2 = 0 ;
8265 bool result;
8266 bool temp2 = false ;
8267 PyObject * obj0 = 0 ;
8268 PyObject * obj1 = 0 ;
8269 char *kwnames[] = {
8270 (char *) "self",(char *) "location", NULL
8271 };
8272
8273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8275 if (SWIG_arg_fail(1)) SWIG_fail;
8276 {
8277 arg2 = wxString_in_helper(obj1);
8278 if (arg2 == NULL) SWIG_fail;
8279 temp2 = true;
8280 }
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 {
8289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8290 }
8291 {
8292 if (temp2)
8293 delete arg2;
8294 }
8295 return resultobj;
8296 fail:
8297 {
8298 if (temp2)
8299 delete arg2;
8300 }
8301 return NULL;
8302 }
8303
8304
8305 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8306 PyObject *resultobj;
8307 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8308 wxFileSystem *arg2 = 0 ;
8309 wxString *arg3 = 0 ;
8310 wxFSFile *result;
8311 bool temp3 = false ;
8312 PyObject * obj0 = 0 ;
8313 PyObject * obj1 = 0 ;
8314 PyObject * obj2 = 0 ;
8315 char *kwnames[] = {
8316 (char *) "self",(char *) "fs",(char *) "location", NULL
8317 };
8318
8319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8321 if (SWIG_arg_fail(1)) SWIG_fail;
8322 {
8323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8324 if (SWIG_arg_fail(2)) SWIG_fail;
8325 if (arg2 == NULL) {
8326 SWIG_null_ref("wxFileSystem");
8327 }
8328 if (SWIG_arg_fail(2)) SWIG_fail;
8329 }
8330 {
8331 arg3 = wxString_in_helper(obj2);
8332 if (arg3 == NULL) SWIG_fail;
8333 temp3 = true;
8334 }
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8338
8339 wxPyEndAllowThreads(__tstate);
8340 if (PyErr_Occurred()) SWIG_fail;
8341 }
8342 {
8343 resultobj = wxPyMake_wxObject(result, 1);
8344 }
8345 {
8346 if (temp3)
8347 delete arg3;
8348 }
8349 return resultobj;
8350 fail:
8351 {
8352 if (temp3)
8353 delete arg3;
8354 }
8355 return NULL;
8356 }
8357
8358
8359 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8360 PyObject *resultobj;
8361 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8362 wxString *arg2 = 0 ;
8363 int arg3 = (int) 0 ;
8364 wxString result;
8365 bool temp2 = false ;
8366 PyObject * obj0 = 0 ;
8367 PyObject * obj1 = 0 ;
8368 PyObject * obj2 = 0 ;
8369 char *kwnames[] = {
8370 (char *) "self",(char *) "spec",(char *) "flags", NULL
8371 };
8372
8373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8375 if (SWIG_arg_fail(1)) SWIG_fail;
8376 {
8377 arg2 = wxString_in_helper(obj1);
8378 if (arg2 == NULL) SWIG_fail;
8379 temp2 = true;
8380 }
8381 if (obj2) {
8382 {
8383 arg3 = (int)(SWIG_As_int(obj2));
8384 if (SWIG_arg_fail(3)) SWIG_fail;
8385 }
8386 }
8387 {
8388 PyThreadState* __tstate = wxPyBeginAllowThreads();
8389 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8390
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 {
8395 #if wxUSE_UNICODE
8396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8397 #else
8398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8399 #endif
8400 }
8401 {
8402 if (temp2)
8403 delete arg2;
8404 }
8405 return resultobj;
8406 fail:
8407 {
8408 if (temp2)
8409 delete arg2;
8410 }
8411 return NULL;
8412 }
8413
8414
8415 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8416 PyObject *resultobj;
8417 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8418 wxString result;
8419 PyObject * obj0 = 0 ;
8420 char *kwnames[] = {
8421 (char *) "self", NULL
8422 };
8423
8424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8426 if (SWIG_arg_fail(1)) SWIG_fail;
8427 {
8428 PyThreadState* __tstate = wxPyBeginAllowThreads();
8429 result = (arg1)->FindNext();
8430
8431 wxPyEndAllowThreads(__tstate);
8432 if (PyErr_Occurred()) SWIG_fail;
8433 }
8434 {
8435 #if wxUSE_UNICODE
8436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8437 #else
8438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8439 #endif
8440 }
8441 return resultobj;
8442 fail:
8443 return NULL;
8444 }
8445
8446
8447 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8448 PyObject *resultobj;
8449 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8450 wxString *arg2 = 0 ;
8451 wxString result;
8452 bool temp2 = false ;
8453 PyObject * obj0 = 0 ;
8454 PyObject * obj1 = 0 ;
8455 char *kwnames[] = {
8456 (char *) "self",(char *) "location", NULL
8457 };
8458
8459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8461 if (SWIG_arg_fail(1)) SWIG_fail;
8462 {
8463 arg2 = wxString_in_helper(obj1);
8464 if (arg2 == NULL) SWIG_fail;
8465 temp2 = true;
8466 }
8467 {
8468 PyThreadState* __tstate = wxPyBeginAllowThreads();
8469 result = (arg1)->GetProtocol((wxString const &)*arg2);
8470
8471 wxPyEndAllowThreads(__tstate);
8472 if (PyErr_Occurred()) SWIG_fail;
8473 }
8474 {
8475 #if wxUSE_UNICODE
8476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8477 #else
8478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8479 #endif
8480 }
8481 {
8482 if (temp2)
8483 delete arg2;
8484 }
8485 return resultobj;
8486 fail:
8487 {
8488 if (temp2)
8489 delete arg2;
8490 }
8491 return NULL;
8492 }
8493
8494
8495 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8496 PyObject *resultobj;
8497 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8498 wxString *arg2 = 0 ;
8499 wxString result;
8500 bool temp2 = false ;
8501 PyObject * obj0 = 0 ;
8502 PyObject * obj1 = 0 ;
8503 char *kwnames[] = {
8504 (char *) "self",(char *) "location", NULL
8505 };
8506
8507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8509 if (SWIG_arg_fail(1)) SWIG_fail;
8510 {
8511 arg2 = wxString_in_helper(obj1);
8512 if (arg2 == NULL) SWIG_fail;
8513 temp2 = true;
8514 }
8515 {
8516 PyThreadState* __tstate = wxPyBeginAllowThreads();
8517 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8518
8519 wxPyEndAllowThreads(__tstate);
8520 if (PyErr_Occurred()) SWIG_fail;
8521 }
8522 {
8523 #if wxUSE_UNICODE
8524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8525 #else
8526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8527 #endif
8528 }
8529 {
8530 if (temp2)
8531 delete arg2;
8532 }
8533 return resultobj;
8534 fail:
8535 {
8536 if (temp2)
8537 delete arg2;
8538 }
8539 return NULL;
8540 }
8541
8542
8543 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8544 PyObject *resultobj;
8545 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8546 wxString *arg2 = 0 ;
8547 wxString result;
8548 bool temp2 = false ;
8549 PyObject * obj0 = 0 ;
8550 PyObject * obj1 = 0 ;
8551 char *kwnames[] = {
8552 (char *) "self",(char *) "location", NULL
8553 };
8554
8555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8557 if (SWIG_arg_fail(1)) SWIG_fail;
8558 {
8559 arg2 = wxString_in_helper(obj1);
8560 if (arg2 == NULL) SWIG_fail;
8561 temp2 = true;
8562 }
8563 {
8564 PyThreadState* __tstate = wxPyBeginAllowThreads();
8565 result = (arg1)->GetAnchor((wxString const &)*arg2);
8566
8567 wxPyEndAllowThreads(__tstate);
8568 if (PyErr_Occurred()) SWIG_fail;
8569 }
8570 {
8571 #if wxUSE_UNICODE
8572 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8573 #else
8574 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8575 #endif
8576 }
8577 {
8578 if (temp2)
8579 delete arg2;
8580 }
8581 return resultobj;
8582 fail:
8583 {
8584 if (temp2)
8585 delete arg2;
8586 }
8587 return NULL;
8588 }
8589
8590
8591 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8592 PyObject *resultobj;
8593 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8594 wxString *arg2 = 0 ;
8595 wxString result;
8596 bool temp2 = false ;
8597 PyObject * obj0 = 0 ;
8598 PyObject * obj1 = 0 ;
8599 char *kwnames[] = {
8600 (char *) "self",(char *) "location", NULL
8601 };
8602
8603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8605 if (SWIG_arg_fail(1)) SWIG_fail;
8606 {
8607 arg2 = wxString_in_helper(obj1);
8608 if (arg2 == NULL) SWIG_fail;
8609 temp2 = true;
8610 }
8611 {
8612 PyThreadState* __tstate = wxPyBeginAllowThreads();
8613 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8614
8615 wxPyEndAllowThreads(__tstate);
8616 if (PyErr_Occurred()) SWIG_fail;
8617 }
8618 {
8619 #if wxUSE_UNICODE
8620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8621 #else
8622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8623 #endif
8624 }
8625 {
8626 if (temp2)
8627 delete arg2;
8628 }
8629 return resultobj;
8630 fail:
8631 {
8632 if (temp2)
8633 delete arg2;
8634 }
8635 return NULL;
8636 }
8637
8638
8639 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8640 PyObject *resultobj;
8641 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8642 wxString *arg2 = 0 ;
8643 wxString result;
8644 bool temp2 = false ;
8645 PyObject * obj0 = 0 ;
8646 PyObject * obj1 = 0 ;
8647 char *kwnames[] = {
8648 (char *) "self",(char *) "location", NULL
8649 };
8650
8651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8653 if (SWIG_arg_fail(1)) SWIG_fail;
8654 {
8655 arg2 = wxString_in_helper(obj1);
8656 if (arg2 == NULL) SWIG_fail;
8657 temp2 = true;
8658 }
8659 {
8660 PyThreadState* __tstate = wxPyBeginAllowThreads();
8661 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8662
8663 wxPyEndAllowThreads(__tstate);
8664 if (PyErr_Occurred()) SWIG_fail;
8665 }
8666 {
8667 #if wxUSE_UNICODE
8668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8669 #else
8670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8671 #endif
8672 }
8673 {
8674 if (temp2)
8675 delete arg2;
8676 }
8677 return resultobj;
8678 fail:
8679 {
8680 if (temp2)
8681 delete arg2;
8682 }
8683 return NULL;
8684 }
8685
8686
8687 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8688 PyObject *obj;
8689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8690 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8691 Py_INCREF(obj);
8692 return Py_BuildValue((char *)"");
8693 }
8694 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj;
8696 wxFileSystem *result;
8697 char *kwnames[] = {
8698 NULL
8699 };
8700
8701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8702 {
8703 PyThreadState* __tstate = wxPyBeginAllowThreads();
8704 result = (wxFileSystem *)new wxFileSystem();
8705
8706 wxPyEndAllowThreads(__tstate);
8707 if (PyErr_Occurred()) SWIG_fail;
8708 }
8709 {
8710 resultobj = wxPyMake_wxObject(result, 1);
8711 }
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj;
8720 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8721 PyObject * obj0 = 0 ;
8722 char *kwnames[] = {
8723 (char *) "self", NULL
8724 };
8725
8726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8728 if (SWIG_arg_fail(1)) SWIG_fail;
8729 {
8730 PyThreadState* __tstate = wxPyBeginAllowThreads();
8731 delete arg1;
8732
8733 wxPyEndAllowThreads(__tstate);
8734 if (PyErr_Occurred()) SWIG_fail;
8735 }
8736 Py_INCREF(Py_None); resultobj = Py_None;
8737 return resultobj;
8738 fail:
8739 return NULL;
8740 }
8741
8742
8743 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8744 PyObject *resultobj;
8745 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8746 wxString *arg2 = 0 ;
8747 bool arg3 = (bool) false ;
8748 bool temp2 = false ;
8749 PyObject * obj0 = 0 ;
8750 PyObject * obj1 = 0 ;
8751 PyObject * obj2 = 0 ;
8752 char *kwnames[] = {
8753 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8754 };
8755
8756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8758 if (SWIG_arg_fail(1)) SWIG_fail;
8759 {
8760 arg2 = wxString_in_helper(obj1);
8761 if (arg2 == NULL) SWIG_fail;
8762 temp2 = true;
8763 }
8764 if (obj2) {
8765 {
8766 arg3 = (bool)(SWIG_As_bool(obj2));
8767 if (SWIG_arg_fail(3)) SWIG_fail;
8768 }
8769 }
8770 {
8771 PyThreadState* __tstate = wxPyBeginAllowThreads();
8772 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8773
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 Py_INCREF(Py_None); resultobj = Py_None;
8778 {
8779 if (temp2)
8780 delete arg2;
8781 }
8782 return resultobj;
8783 fail:
8784 {
8785 if (temp2)
8786 delete arg2;
8787 }
8788 return NULL;
8789 }
8790
8791
8792 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8793 PyObject *resultobj;
8794 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8795 wxString result;
8796 PyObject * obj0 = 0 ;
8797 char *kwnames[] = {
8798 (char *) "self", NULL
8799 };
8800
8801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8803 if (SWIG_arg_fail(1)) SWIG_fail;
8804 {
8805 PyThreadState* __tstate = wxPyBeginAllowThreads();
8806 result = (arg1)->GetPath();
8807
8808 wxPyEndAllowThreads(__tstate);
8809 if (PyErr_Occurred()) SWIG_fail;
8810 }
8811 {
8812 #if wxUSE_UNICODE
8813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8814 #else
8815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8816 #endif
8817 }
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8825 PyObject *resultobj;
8826 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8827 wxString *arg2 = 0 ;
8828 wxFSFile *result;
8829 bool temp2 = false ;
8830 PyObject * obj0 = 0 ;
8831 PyObject * obj1 = 0 ;
8832 char *kwnames[] = {
8833 (char *) "self",(char *) "location", NULL
8834 };
8835
8836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8838 if (SWIG_arg_fail(1)) SWIG_fail;
8839 {
8840 arg2 = wxString_in_helper(obj1);
8841 if (arg2 == NULL) SWIG_fail;
8842 temp2 = true;
8843 }
8844 {
8845 PyThreadState* __tstate = wxPyBeginAllowThreads();
8846 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8847
8848 wxPyEndAllowThreads(__tstate);
8849 if (PyErr_Occurred()) SWIG_fail;
8850 }
8851 {
8852 resultobj = wxPyMake_wxObject(result, 1);
8853 }
8854 {
8855 if (temp2)
8856 delete arg2;
8857 }
8858 return resultobj;
8859 fail:
8860 {
8861 if (temp2)
8862 delete arg2;
8863 }
8864 return NULL;
8865 }
8866
8867
8868 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8869 PyObject *resultobj;
8870 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8871 wxString *arg2 = 0 ;
8872 int arg3 = (int) 0 ;
8873 wxString result;
8874 bool temp2 = false ;
8875 PyObject * obj0 = 0 ;
8876 PyObject * obj1 = 0 ;
8877 PyObject * obj2 = 0 ;
8878 char *kwnames[] = {
8879 (char *) "self",(char *) "spec",(char *) "flags", NULL
8880 };
8881
8882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8884 if (SWIG_arg_fail(1)) SWIG_fail;
8885 {
8886 arg2 = wxString_in_helper(obj1);
8887 if (arg2 == NULL) SWIG_fail;
8888 temp2 = true;
8889 }
8890 if (obj2) {
8891 {
8892 arg3 = (int)(SWIG_As_int(obj2));
8893 if (SWIG_arg_fail(3)) SWIG_fail;
8894 }
8895 }
8896 {
8897 PyThreadState* __tstate = wxPyBeginAllowThreads();
8898 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8899
8900 wxPyEndAllowThreads(__tstate);
8901 if (PyErr_Occurred()) SWIG_fail;
8902 }
8903 {
8904 #if wxUSE_UNICODE
8905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8906 #else
8907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8908 #endif
8909 }
8910 {
8911 if (temp2)
8912 delete arg2;
8913 }
8914 return resultobj;
8915 fail:
8916 {
8917 if (temp2)
8918 delete arg2;
8919 }
8920 return NULL;
8921 }
8922
8923
8924 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj;
8926 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8927 wxString result;
8928 PyObject * obj0 = 0 ;
8929 char *kwnames[] = {
8930 (char *) "self", NULL
8931 };
8932
8933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8935 if (SWIG_arg_fail(1)) SWIG_fail;
8936 {
8937 PyThreadState* __tstate = wxPyBeginAllowThreads();
8938 result = (arg1)->FindNext();
8939
8940 wxPyEndAllowThreads(__tstate);
8941 if (PyErr_Occurred()) SWIG_fail;
8942 }
8943 {
8944 #if wxUSE_UNICODE
8945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8946 #else
8947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8948 #endif
8949 }
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj;
8958 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8959 PyObject * obj0 = 0 ;
8960 char *kwnames[] = {
8961 (char *) "handler", NULL
8962 };
8963
8964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8966 if (SWIG_arg_fail(1)) SWIG_fail;
8967 {
8968 PyThreadState* __tstate = wxPyBeginAllowThreads();
8969 wxFileSystem::AddHandler(arg1);
8970
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 Py_INCREF(Py_None); resultobj = Py_None;
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8982 PyObject *resultobj;
8983 char *kwnames[] = {
8984 NULL
8985 };
8986
8987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8988 {
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 wxFileSystem::CleanUpHandlers();
8991
8992 wxPyEndAllowThreads(__tstate);
8993 if (PyErr_Occurred()) SWIG_fail;
8994 }
8995 Py_INCREF(Py_None); resultobj = Py_None;
8996 return resultobj;
8997 fail:
8998 return NULL;
8999 }
9000
9001
9002 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9003 PyObject *resultobj;
9004 wxString *arg1 = 0 ;
9005 wxString result;
9006 bool temp1 = false ;
9007 PyObject * obj0 = 0 ;
9008 char *kwnames[] = {
9009 (char *) "filename", NULL
9010 };
9011
9012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9013 {
9014 arg1 = wxString_in_helper(obj0);
9015 if (arg1 == NULL) SWIG_fail;
9016 temp1 = true;
9017 }
9018 {
9019 PyThreadState* __tstate = wxPyBeginAllowThreads();
9020 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9021
9022 wxPyEndAllowThreads(__tstate);
9023 if (PyErr_Occurred()) SWIG_fail;
9024 }
9025 {
9026 #if wxUSE_UNICODE
9027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9028 #else
9029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9030 #endif
9031 }
9032 {
9033 if (temp1)
9034 delete arg1;
9035 }
9036 return resultobj;
9037 fail:
9038 {
9039 if (temp1)
9040 delete arg1;
9041 }
9042 return NULL;
9043 }
9044
9045
9046 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj;
9048 wxString *arg1 = 0 ;
9049 wxString result;
9050 bool temp1 = false ;
9051 PyObject * obj0 = 0 ;
9052 char *kwnames[] = {
9053 (char *) "url", NULL
9054 };
9055
9056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9057 {
9058 arg1 = wxString_in_helper(obj0);
9059 if (arg1 == NULL) SWIG_fail;
9060 temp1 = true;
9061 }
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 result = FileSystem_URLToFileName((wxString const &)*arg1);
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 {
9070 #if wxUSE_UNICODE
9071 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9072 #else
9073 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9074 #endif
9075 }
9076 {
9077 if (temp1)
9078 delete arg1;
9079 }
9080 return resultobj;
9081 fail:
9082 {
9083 if (temp1)
9084 delete arg1;
9085 }
9086 return NULL;
9087 }
9088
9089
9090 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9091 PyObject *obj;
9092 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9093 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9094 Py_INCREF(obj);
9095 return Py_BuildValue((char *)"");
9096 }
9097 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9098 PyObject *resultobj;
9099 wxInternetFSHandler *result;
9100 char *kwnames[] = {
9101 NULL
9102 };
9103
9104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9105 {
9106 PyThreadState* __tstate = wxPyBeginAllowThreads();
9107 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9108
9109 wxPyEndAllowThreads(__tstate);
9110 if (PyErr_Occurred()) SWIG_fail;
9111 }
9112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9113 return resultobj;
9114 fail:
9115 return NULL;
9116 }
9117
9118
9119 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9120 PyObject *resultobj;
9121 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9122 wxString *arg2 = 0 ;
9123 bool result;
9124 bool temp2 = false ;
9125 PyObject * obj0 = 0 ;
9126 PyObject * obj1 = 0 ;
9127 char *kwnames[] = {
9128 (char *) "self",(char *) "location", NULL
9129 };
9130
9131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9133 if (SWIG_arg_fail(1)) SWIG_fail;
9134 {
9135 arg2 = wxString_in_helper(obj1);
9136 if (arg2 == NULL) SWIG_fail;
9137 temp2 = true;
9138 }
9139 {
9140 PyThreadState* __tstate = wxPyBeginAllowThreads();
9141 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9142
9143 wxPyEndAllowThreads(__tstate);
9144 if (PyErr_Occurred()) SWIG_fail;
9145 }
9146 {
9147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9148 }
9149 {
9150 if (temp2)
9151 delete arg2;
9152 }
9153 return resultobj;
9154 fail:
9155 {
9156 if (temp2)
9157 delete arg2;
9158 }
9159 return NULL;
9160 }
9161
9162
9163 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9164 PyObject *resultobj;
9165 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9166 wxFileSystem *arg2 = 0 ;
9167 wxString *arg3 = 0 ;
9168 wxFSFile *result;
9169 bool temp3 = false ;
9170 PyObject * obj0 = 0 ;
9171 PyObject * obj1 = 0 ;
9172 PyObject * obj2 = 0 ;
9173 char *kwnames[] = {
9174 (char *) "self",(char *) "fs",(char *) "location", NULL
9175 };
9176
9177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9179 if (SWIG_arg_fail(1)) SWIG_fail;
9180 {
9181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9182 if (SWIG_arg_fail(2)) SWIG_fail;
9183 if (arg2 == NULL) {
9184 SWIG_null_ref("wxFileSystem");
9185 }
9186 if (SWIG_arg_fail(2)) SWIG_fail;
9187 }
9188 {
9189 arg3 = wxString_in_helper(obj2);
9190 if (arg3 == NULL) SWIG_fail;
9191 temp3 = true;
9192 }
9193 {
9194 PyThreadState* __tstate = wxPyBeginAllowThreads();
9195 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9196
9197 wxPyEndAllowThreads(__tstate);
9198 if (PyErr_Occurred()) SWIG_fail;
9199 }
9200 {
9201 resultobj = wxPyMake_wxObject(result, 1);
9202 }
9203 {
9204 if (temp3)
9205 delete arg3;
9206 }
9207 return resultobj;
9208 fail:
9209 {
9210 if (temp3)
9211 delete arg3;
9212 }
9213 return NULL;
9214 }
9215
9216
9217 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9218 PyObject *obj;
9219 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9220 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9221 Py_INCREF(obj);
9222 return Py_BuildValue((char *)"");
9223 }
9224 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9225 PyObject *resultobj;
9226 wxZipFSHandler *result;
9227 char *kwnames[] = {
9228 NULL
9229 };
9230
9231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9232 {
9233 PyThreadState* __tstate = wxPyBeginAllowThreads();
9234 result = (wxZipFSHandler *)new wxZipFSHandler();
9235
9236 wxPyEndAllowThreads(__tstate);
9237 if (PyErr_Occurred()) SWIG_fail;
9238 }
9239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9240 return resultobj;
9241 fail:
9242 return NULL;
9243 }
9244
9245
9246 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9247 PyObject *resultobj;
9248 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9249 wxString *arg2 = 0 ;
9250 bool result;
9251 bool temp2 = false ;
9252 PyObject * obj0 = 0 ;
9253 PyObject * obj1 = 0 ;
9254 char *kwnames[] = {
9255 (char *) "self",(char *) "location", NULL
9256 };
9257
9258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9260 if (SWIG_arg_fail(1)) SWIG_fail;
9261 {
9262 arg2 = wxString_in_helper(obj1);
9263 if (arg2 == NULL) SWIG_fail;
9264 temp2 = true;
9265 }
9266 {
9267 PyThreadState* __tstate = wxPyBeginAllowThreads();
9268 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9269
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 {
9274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9275 }
9276 {
9277 if (temp2)
9278 delete arg2;
9279 }
9280 return resultobj;
9281 fail:
9282 {
9283 if (temp2)
9284 delete arg2;
9285 }
9286 return NULL;
9287 }
9288
9289
9290 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9291 PyObject *resultobj;
9292 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9293 wxFileSystem *arg2 = 0 ;
9294 wxString *arg3 = 0 ;
9295 wxFSFile *result;
9296 bool temp3 = false ;
9297 PyObject * obj0 = 0 ;
9298 PyObject * obj1 = 0 ;
9299 PyObject * obj2 = 0 ;
9300 char *kwnames[] = {
9301 (char *) "self",(char *) "fs",(char *) "location", NULL
9302 };
9303
9304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9306 if (SWIG_arg_fail(1)) SWIG_fail;
9307 {
9308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9309 if (SWIG_arg_fail(2)) SWIG_fail;
9310 if (arg2 == NULL) {
9311 SWIG_null_ref("wxFileSystem");
9312 }
9313 if (SWIG_arg_fail(2)) SWIG_fail;
9314 }
9315 {
9316 arg3 = wxString_in_helper(obj2);
9317 if (arg3 == NULL) SWIG_fail;
9318 temp3 = true;
9319 }
9320 {
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9323
9324 wxPyEndAllowThreads(__tstate);
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 {
9328 resultobj = wxPyMake_wxObject(result, 1);
9329 }
9330 {
9331 if (temp3)
9332 delete arg3;
9333 }
9334 return resultobj;
9335 fail:
9336 {
9337 if (temp3)
9338 delete arg3;
9339 }
9340 return NULL;
9341 }
9342
9343
9344 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9345 PyObject *resultobj;
9346 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9347 wxString *arg2 = 0 ;
9348 int arg3 = (int) 0 ;
9349 wxString result;
9350 bool temp2 = false ;
9351 PyObject * obj0 = 0 ;
9352 PyObject * obj1 = 0 ;
9353 PyObject * obj2 = 0 ;
9354 char *kwnames[] = {
9355 (char *) "self",(char *) "spec",(char *) "flags", NULL
9356 };
9357
9358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9360 if (SWIG_arg_fail(1)) SWIG_fail;
9361 {
9362 arg2 = wxString_in_helper(obj1);
9363 if (arg2 == NULL) SWIG_fail;
9364 temp2 = true;
9365 }
9366 if (obj2) {
9367 {
9368 arg3 = (int)(SWIG_As_int(obj2));
9369 if (SWIG_arg_fail(3)) SWIG_fail;
9370 }
9371 }
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9375
9376 wxPyEndAllowThreads(__tstate);
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 {
9380 #if wxUSE_UNICODE
9381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9382 #else
9383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9384 #endif
9385 }
9386 {
9387 if (temp2)
9388 delete arg2;
9389 }
9390 return resultobj;
9391 fail:
9392 {
9393 if (temp2)
9394 delete arg2;
9395 }
9396 return NULL;
9397 }
9398
9399
9400 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9401 PyObject *resultobj;
9402 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9403 wxString result;
9404 PyObject * obj0 = 0 ;
9405 char *kwnames[] = {
9406 (char *) "self", NULL
9407 };
9408
9409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9411 if (SWIG_arg_fail(1)) SWIG_fail;
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 result = (arg1)->FindNext();
9415
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 {
9420 #if wxUSE_UNICODE
9421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9422 #else
9423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9424 #endif
9425 }
9426 return resultobj;
9427 fail:
9428 return NULL;
9429 }
9430
9431
9432 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9433 PyObject *obj;
9434 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9435 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9436 Py_INCREF(obj);
9437 return Py_BuildValue((char *)"");
9438 }
9439 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj;
9441 wxString *arg1 = 0 ;
9442 wxImage *arg2 = 0 ;
9443 long arg3 ;
9444 bool temp1 = false ;
9445 PyObject * obj0 = 0 ;
9446 PyObject * obj1 = 0 ;
9447 PyObject * obj2 = 0 ;
9448 char *kwnames[] = {
9449 (char *) "filename",(char *) "image",(char *) "type", NULL
9450 };
9451
9452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9453 {
9454 arg1 = wxString_in_helper(obj0);
9455 if (arg1 == NULL) SWIG_fail;
9456 temp1 = true;
9457 }
9458 {
9459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9460 if (SWIG_arg_fail(2)) SWIG_fail;
9461 if (arg2 == NULL) {
9462 SWIG_null_ref("wxImage");
9463 }
9464 if (SWIG_arg_fail(2)) SWIG_fail;
9465 }
9466 {
9467 arg3 = (long)(SWIG_As_long(obj2));
9468 if (SWIG_arg_fail(3)) SWIG_fail;
9469 }
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9473
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 Py_INCREF(Py_None); resultobj = Py_None;
9478 {
9479 if (temp1)
9480 delete arg1;
9481 }
9482 return resultobj;
9483 fail:
9484 {
9485 if (temp1)
9486 delete arg1;
9487 }
9488 return NULL;
9489 }
9490
9491
9492 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9493 PyObject *resultobj;
9494 wxString *arg1 = 0 ;
9495 wxBitmap *arg2 = 0 ;
9496 long arg3 ;
9497 bool temp1 = false ;
9498 PyObject * obj0 = 0 ;
9499 PyObject * obj1 = 0 ;
9500 PyObject * obj2 = 0 ;
9501 char *kwnames[] = {
9502 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9503 };
9504
9505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9506 {
9507 arg1 = wxString_in_helper(obj0);
9508 if (arg1 == NULL) SWIG_fail;
9509 temp1 = true;
9510 }
9511 {
9512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9513 if (SWIG_arg_fail(2)) SWIG_fail;
9514 if (arg2 == NULL) {
9515 SWIG_null_ref("wxBitmap");
9516 }
9517 if (SWIG_arg_fail(2)) SWIG_fail;
9518 }
9519 {
9520 arg3 = (long)(SWIG_As_long(obj2));
9521 if (SWIG_arg_fail(3)) SWIG_fail;
9522 }
9523 {
9524 PyThreadState* __tstate = wxPyBeginAllowThreads();
9525 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9526
9527 wxPyEndAllowThreads(__tstate);
9528 if (PyErr_Occurred()) SWIG_fail;
9529 }
9530 Py_INCREF(Py_None); resultobj = Py_None;
9531 {
9532 if (temp1)
9533 delete arg1;
9534 }
9535 return resultobj;
9536 fail:
9537 {
9538 if (temp1)
9539 delete arg1;
9540 }
9541 return NULL;
9542 }
9543
9544
9545 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9546 PyObject *resultobj;
9547 wxString *arg1 = 0 ;
9548 PyObject *arg2 = (PyObject *) 0 ;
9549 bool temp1 = false ;
9550 PyObject * obj0 = 0 ;
9551 PyObject * obj1 = 0 ;
9552 char *kwnames[] = {
9553 (char *) "filename",(char *) "data", NULL
9554 };
9555
9556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9557 {
9558 arg1 = wxString_in_helper(obj0);
9559 if (arg1 == NULL) SWIG_fail;
9560 temp1 = true;
9561 }
9562 arg2 = obj1;
9563 {
9564 PyThreadState* __tstate = wxPyBeginAllowThreads();
9565 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9566
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 Py_INCREF(Py_None); resultobj = Py_None;
9571 {
9572 if (temp1)
9573 delete arg1;
9574 }
9575 return resultobj;
9576 fail:
9577 {
9578 if (temp1)
9579 delete arg1;
9580 }
9581 return NULL;
9582 }
9583
9584
9585 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9586 PyObject *resultobj;
9587 wxMemoryFSHandler *result;
9588 char *kwnames[] = {
9589 NULL
9590 };
9591
9592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9593 {
9594 PyThreadState* __tstate = wxPyBeginAllowThreads();
9595 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9596
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9608 PyObject *resultobj;
9609 wxString *arg1 = 0 ;
9610 bool temp1 = false ;
9611 PyObject * obj0 = 0 ;
9612 char *kwnames[] = {
9613 (char *) "filename", NULL
9614 };
9615
9616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9617 {
9618 arg1 = wxString_in_helper(obj0);
9619 if (arg1 == NULL) SWIG_fail;
9620 temp1 = true;
9621 }
9622 {
9623 PyThreadState* __tstate = wxPyBeginAllowThreads();
9624 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9625
9626 wxPyEndAllowThreads(__tstate);
9627 if (PyErr_Occurred()) SWIG_fail;
9628 }
9629 Py_INCREF(Py_None); resultobj = Py_None;
9630 {
9631 if (temp1)
9632 delete arg1;
9633 }
9634 return resultobj;
9635 fail:
9636 {
9637 if (temp1)
9638 delete arg1;
9639 }
9640 return NULL;
9641 }
9642
9643
9644 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9645 PyObject *resultobj;
9646 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9647 wxString *arg2 = 0 ;
9648 bool result;
9649 bool temp2 = false ;
9650 PyObject * obj0 = 0 ;
9651 PyObject * obj1 = 0 ;
9652 char *kwnames[] = {
9653 (char *) "self",(char *) "location", NULL
9654 };
9655
9656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9658 if (SWIG_arg_fail(1)) SWIG_fail;
9659 {
9660 arg2 = wxString_in_helper(obj1);
9661 if (arg2 == NULL) SWIG_fail;
9662 temp2 = true;
9663 }
9664 {
9665 PyThreadState* __tstate = wxPyBeginAllowThreads();
9666 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9667
9668 wxPyEndAllowThreads(__tstate);
9669 if (PyErr_Occurred()) SWIG_fail;
9670 }
9671 {
9672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9673 }
9674 {
9675 if (temp2)
9676 delete arg2;
9677 }
9678 return resultobj;
9679 fail:
9680 {
9681 if (temp2)
9682 delete arg2;
9683 }
9684 return NULL;
9685 }
9686
9687
9688 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9689 PyObject *resultobj;
9690 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9691 wxFileSystem *arg2 = 0 ;
9692 wxString *arg3 = 0 ;
9693 wxFSFile *result;
9694 bool temp3 = false ;
9695 PyObject * obj0 = 0 ;
9696 PyObject * obj1 = 0 ;
9697 PyObject * obj2 = 0 ;
9698 char *kwnames[] = {
9699 (char *) "self",(char *) "fs",(char *) "location", NULL
9700 };
9701
9702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9704 if (SWIG_arg_fail(1)) SWIG_fail;
9705 {
9706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9707 if (SWIG_arg_fail(2)) SWIG_fail;
9708 if (arg2 == NULL) {
9709 SWIG_null_ref("wxFileSystem");
9710 }
9711 if (SWIG_arg_fail(2)) SWIG_fail;
9712 }
9713 {
9714 arg3 = wxString_in_helper(obj2);
9715 if (arg3 == NULL) SWIG_fail;
9716 temp3 = true;
9717 }
9718 {
9719 PyThreadState* __tstate = wxPyBeginAllowThreads();
9720 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9721
9722 wxPyEndAllowThreads(__tstate);
9723 if (PyErr_Occurred()) SWIG_fail;
9724 }
9725 {
9726 resultobj = wxPyMake_wxObject(result, 1);
9727 }
9728 {
9729 if (temp3)
9730 delete arg3;
9731 }
9732 return resultobj;
9733 fail:
9734 {
9735 if (temp3)
9736 delete arg3;
9737 }
9738 return NULL;
9739 }
9740
9741
9742 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9743 PyObject *resultobj;
9744 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9745 wxString *arg2 = 0 ;
9746 int arg3 = (int) 0 ;
9747 wxString result;
9748 bool temp2 = false ;
9749 PyObject * obj0 = 0 ;
9750 PyObject * obj1 = 0 ;
9751 PyObject * obj2 = 0 ;
9752 char *kwnames[] = {
9753 (char *) "self",(char *) "spec",(char *) "flags", NULL
9754 };
9755
9756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9758 if (SWIG_arg_fail(1)) SWIG_fail;
9759 {
9760 arg2 = wxString_in_helper(obj1);
9761 if (arg2 == NULL) SWIG_fail;
9762 temp2 = true;
9763 }
9764 if (obj2) {
9765 {
9766 arg3 = (int)(SWIG_As_int(obj2));
9767 if (SWIG_arg_fail(3)) SWIG_fail;
9768 }
9769 }
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9773
9774 wxPyEndAllowThreads(__tstate);
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 {
9778 #if wxUSE_UNICODE
9779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9780 #else
9781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9782 #endif
9783 }
9784 {
9785 if (temp2)
9786 delete arg2;
9787 }
9788 return resultobj;
9789 fail:
9790 {
9791 if (temp2)
9792 delete arg2;
9793 }
9794 return NULL;
9795 }
9796
9797
9798 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9799 PyObject *resultobj;
9800 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9801 wxString result;
9802 PyObject * obj0 = 0 ;
9803 char *kwnames[] = {
9804 (char *) "self", NULL
9805 };
9806
9807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9809 if (SWIG_arg_fail(1)) SWIG_fail;
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 result = (arg1)->FindNext();
9813
9814 wxPyEndAllowThreads(__tstate);
9815 if (PyErr_Occurred()) SWIG_fail;
9816 }
9817 {
9818 #if wxUSE_UNICODE
9819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9820 #else
9821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9822 #endif
9823 }
9824 return resultobj;
9825 fail:
9826 return NULL;
9827 }
9828
9829
9830 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9831 PyObject *obj;
9832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9833 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9834 Py_INCREF(obj);
9835 return Py_BuildValue((char *)"");
9836 }
9837 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9838 PyObject *resultobj;
9839 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9840 wxString result;
9841 PyObject * obj0 = 0 ;
9842 char *kwnames[] = {
9843 (char *) "self", NULL
9844 };
9845
9846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9848 if (SWIG_arg_fail(1)) SWIG_fail;
9849 {
9850 PyThreadState* __tstate = wxPyBeginAllowThreads();
9851 result = (arg1)->GetName();
9852
9853 wxPyEndAllowThreads(__tstate);
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 {
9857 #if wxUSE_UNICODE
9858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9859 #else
9860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9861 #endif
9862 }
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj;
9871 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9872 wxString result;
9873 PyObject * obj0 = 0 ;
9874 char *kwnames[] = {
9875 (char *) "self", NULL
9876 };
9877
9878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9880 if (SWIG_arg_fail(1)) SWIG_fail;
9881 {
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (arg1)->GetExtension();
9884
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 #if wxUSE_UNICODE
9890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9891 #else
9892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9893 #endif
9894 }
9895 return resultobj;
9896 fail:
9897 return NULL;
9898 }
9899
9900
9901 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9902 PyObject *resultobj;
9903 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9904 long result;
9905 PyObject * obj0 = 0 ;
9906 char *kwnames[] = {
9907 (char *) "self", NULL
9908 };
9909
9910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9912 if (SWIG_arg_fail(1)) SWIG_fail;
9913 {
9914 PyThreadState* __tstate = wxPyBeginAllowThreads();
9915 result = (long)(arg1)->GetType();
9916
9917 wxPyEndAllowThreads(__tstate);
9918 if (PyErr_Occurred()) SWIG_fail;
9919 }
9920 {
9921 resultobj = SWIG_From_long((long)(result));
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9930 PyObject *resultobj;
9931 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9932 wxString result;
9933 PyObject * obj0 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "self", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9940 if (SWIG_arg_fail(1)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = (arg1)->GetMimeType();
9944
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 {
9949 #if wxUSE_UNICODE
9950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9951 #else
9952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9953 #endif
9954 }
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj;
9963 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9964 wxString *arg2 = 0 ;
9965 bool result;
9966 bool temp2 = false ;
9967 PyObject * obj0 = 0 ;
9968 PyObject * obj1 = 0 ;
9969 char *kwnames[] = {
9970 (char *) "self",(char *) "name", NULL
9971 };
9972
9973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9975 if (SWIG_arg_fail(1)) SWIG_fail;
9976 {
9977 arg2 = wxString_in_helper(obj1);
9978 if (arg2 == NULL) SWIG_fail;
9979 temp2 = true;
9980 }
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9984
9985 wxPyEndAllowThreads(__tstate);
9986 if (PyErr_Occurred()) SWIG_fail;
9987 }
9988 {
9989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9990 }
9991 {
9992 if (temp2)
9993 delete arg2;
9994 }
9995 return resultobj;
9996 fail:
9997 {
9998 if (temp2)
9999 delete arg2;
10000 }
10001 return NULL;
10002 }
10003
10004
10005 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10006 PyObject *resultobj;
10007 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10008 wxString *arg2 = 0 ;
10009 bool temp2 = false ;
10010 PyObject * obj0 = 0 ;
10011 PyObject * obj1 = 0 ;
10012 char *kwnames[] = {
10013 (char *) "self",(char *) "name", NULL
10014 };
10015
10016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10018 if (SWIG_arg_fail(1)) SWIG_fail;
10019 {
10020 arg2 = wxString_in_helper(obj1);
10021 if (arg2 == NULL) SWIG_fail;
10022 temp2 = true;
10023 }
10024 {
10025 PyThreadState* __tstate = wxPyBeginAllowThreads();
10026 (arg1)->SetName((wxString const &)*arg2);
10027
10028 wxPyEndAllowThreads(__tstate);
10029 if (PyErr_Occurred()) SWIG_fail;
10030 }
10031 Py_INCREF(Py_None); resultobj = Py_None;
10032 {
10033 if (temp2)
10034 delete arg2;
10035 }
10036 return resultobj;
10037 fail:
10038 {
10039 if (temp2)
10040 delete arg2;
10041 }
10042 return NULL;
10043 }
10044
10045
10046 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10047 PyObject *resultobj;
10048 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10049 wxString *arg2 = 0 ;
10050 bool temp2 = false ;
10051 PyObject * obj0 = 0 ;
10052 PyObject * obj1 = 0 ;
10053 char *kwnames[] = {
10054 (char *) "self",(char *) "extension", NULL
10055 };
10056
10057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10059 if (SWIG_arg_fail(1)) SWIG_fail;
10060 {
10061 arg2 = wxString_in_helper(obj1);
10062 if (arg2 == NULL) SWIG_fail;
10063 temp2 = true;
10064 }
10065 {
10066 PyThreadState* __tstate = wxPyBeginAllowThreads();
10067 (arg1)->SetExtension((wxString const &)*arg2);
10068
10069 wxPyEndAllowThreads(__tstate);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 Py_INCREF(Py_None); resultobj = Py_None;
10073 {
10074 if (temp2)
10075 delete arg2;
10076 }
10077 return resultobj;
10078 fail:
10079 {
10080 if (temp2)
10081 delete arg2;
10082 }
10083 return NULL;
10084 }
10085
10086
10087 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj;
10089 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10090 long arg2 ;
10091 PyObject * obj0 = 0 ;
10092 PyObject * obj1 = 0 ;
10093 char *kwnames[] = {
10094 (char *) "self",(char *) "type", NULL
10095 };
10096
10097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10099 if (SWIG_arg_fail(1)) SWIG_fail;
10100 {
10101 arg2 = (long)(SWIG_As_long(obj1));
10102 if (SWIG_arg_fail(2)) SWIG_fail;
10103 }
10104 {
10105 PyThreadState* __tstate = wxPyBeginAllowThreads();
10106 (arg1)->SetType(arg2);
10107
10108 wxPyEndAllowThreads(__tstate);
10109 if (PyErr_Occurred()) SWIG_fail;
10110 }
10111 Py_INCREF(Py_None); resultobj = Py_None;
10112 return resultobj;
10113 fail:
10114 return NULL;
10115 }
10116
10117
10118 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10119 PyObject *resultobj;
10120 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10121 wxString *arg2 = 0 ;
10122 bool temp2 = false ;
10123 PyObject * obj0 = 0 ;
10124 PyObject * obj1 = 0 ;
10125 char *kwnames[] = {
10126 (char *) "self",(char *) "mimetype", NULL
10127 };
10128
10129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10131 if (SWIG_arg_fail(1)) SWIG_fail;
10132 {
10133 arg2 = wxString_in_helper(obj1);
10134 if (arg2 == NULL) SWIG_fail;
10135 temp2 = true;
10136 }
10137 {
10138 PyThreadState* __tstate = wxPyBeginAllowThreads();
10139 (arg1)->SetMimeType((wxString const &)*arg2);
10140
10141 wxPyEndAllowThreads(__tstate);
10142 if (PyErr_Occurred()) SWIG_fail;
10143 }
10144 Py_INCREF(Py_None); resultobj = Py_None;
10145 {
10146 if (temp2)
10147 delete arg2;
10148 }
10149 return resultobj;
10150 fail:
10151 {
10152 if (temp2)
10153 delete arg2;
10154 }
10155 return NULL;
10156 }
10157
10158
10159 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10160 PyObject *obj;
10161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10162 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10163 Py_INCREF(obj);
10164 return Py_BuildValue((char *)"");
10165 }
10166 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10167 PyObject *resultobj;
10168 wxImageHistogram *result;
10169 char *kwnames[] = {
10170 NULL
10171 };
10172
10173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10174 {
10175 PyThreadState* __tstate = wxPyBeginAllowThreads();
10176 result = (wxImageHistogram *)new wxImageHistogram();
10177
10178 wxPyEndAllowThreads(__tstate);
10179 if (PyErr_Occurred()) SWIG_fail;
10180 }
10181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10182 return resultobj;
10183 fail:
10184 return NULL;
10185 }
10186
10187
10188 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10189 PyObject *resultobj;
10190 unsigned char arg1 ;
10191 unsigned char arg2 ;
10192 unsigned char arg3 ;
10193 unsigned long result;
10194 PyObject * obj0 = 0 ;
10195 PyObject * obj1 = 0 ;
10196 PyObject * obj2 = 0 ;
10197 char *kwnames[] = {
10198 (char *) "r",(char *) "g",(char *) "b", NULL
10199 };
10200
10201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10202 {
10203 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10204 if (SWIG_arg_fail(1)) SWIG_fail;
10205 }
10206 {
10207 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10208 if (SWIG_arg_fail(2)) SWIG_fail;
10209 }
10210 {
10211 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10212 if (SWIG_arg_fail(3)) SWIG_fail;
10213 }
10214 {
10215 PyThreadState* __tstate = wxPyBeginAllowThreads();
10216 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10217
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 {
10222 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10223 }
10224 return resultobj;
10225 fail:
10226 return NULL;
10227 }
10228
10229
10230 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10231 PyObject *resultobj;
10232 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10233 unsigned char *arg2 = (unsigned char *) 0 ;
10234 unsigned char *arg3 = (unsigned char *) 0 ;
10235 unsigned char *arg4 = (unsigned char *) 0 ;
10236 unsigned char arg5 = (unsigned char) 1 ;
10237 unsigned char arg6 = (unsigned char) 0 ;
10238 unsigned char arg7 = (unsigned char) 0 ;
10239 bool result;
10240 unsigned char temp2 ;
10241 int res2 = 0 ;
10242 unsigned char temp3 ;
10243 int res3 = 0 ;
10244 unsigned char temp4 ;
10245 int res4 = 0 ;
10246 PyObject * obj0 = 0 ;
10247 PyObject * obj1 = 0 ;
10248 PyObject * obj2 = 0 ;
10249 PyObject * obj3 = 0 ;
10250 char *kwnames[] = {
10251 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10252 };
10253
10254 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10255 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10256 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10259 if (SWIG_arg_fail(1)) SWIG_fail;
10260 if (obj1) {
10261 {
10262 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10263 if (SWIG_arg_fail(5)) SWIG_fail;
10264 }
10265 }
10266 if (obj2) {
10267 {
10268 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10269 if (SWIG_arg_fail(6)) SWIG_fail;
10270 }
10271 }
10272 if (obj3) {
10273 {
10274 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10275 if (SWIG_arg_fail(7)) SWIG_fail;
10276 }
10277 }
10278 {
10279 PyThreadState* __tstate = wxPyBeginAllowThreads();
10280 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10281
10282 wxPyEndAllowThreads(__tstate);
10283 if (PyErr_Occurred()) SWIG_fail;
10284 }
10285 {
10286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10287 }
10288 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10289 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10290 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10291 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10292 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10293 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10294 return resultobj;
10295 fail:
10296 return NULL;
10297 }
10298
10299
10300 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10301 PyObject *obj;
10302 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10303 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10304 Py_INCREF(obj);
10305 return Py_BuildValue((char *)"");
10306 }
10307 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10308 PyObject *resultobj;
10309 wxString *arg1 = 0 ;
10310 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10311 int arg3 = (int) -1 ;
10312 wxImage *result;
10313 bool temp1 = false ;
10314 PyObject * obj0 = 0 ;
10315 PyObject * obj1 = 0 ;
10316 PyObject * obj2 = 0 ;
10317 char *kwnames[] = {
10318 (char *) "name",(char *) "type",(char *) "index", NULL
10319 };
10320
10321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10322 {
10323 arg1 = wxString_in_helper(obj0);
10324 if (arg1 == NULL) SWIG_fail;
10325 temp1 = true;
10326 }
10327 if (obj1) {
10328 {
10329 arg2 = (long)(SWIG_As_long(obj1));
10330 if (SWIG_arg_fail(2)) SWIG_fail;
10331 }
10332 }
10333 if (obj2) {
10334 {
10335 arg3 = (int)(SWIG_As_int(obj2));
10336 if (SWIG_arg_fail(3)) SWIG_fail;
10337 }
10338 }
10339 {
10340 PyThreadState* __tstate = wxPyBeginAllowThreads();
10341 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10342
10343 wxPyEndAllowThreads(__tstate);
10344 if (PyErr_Occurred()) SWIG_fail;
10345 }
10346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10347 {
10348 if (temp1)
10349 delete arg1;
10350 }
10351 return resultobj;
10352 fail:
10353 {
10354 if (temp1)
10355 delete arg1;
10356 }
10357 return NULL;
10358 }
10359
10360
10361 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10362 PyObject *resultobj;
10363 wxImage *arg1 = (wxImage *) 0 ;
10364 PyObject * obj0 = 0 ;
10365 char *kwnames[] = {
10366 (char *) "self", NULL
10367 };
10368
10369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10371 if (SWIG_arg_fail(1)) SWIG_fail;
10372 {
10373 PyThreadState* __tstate = wxPyBeginAllowThreads();
10374 delete arg1;
10375
10376 wxPyEndAllowThreads(__tstate);
10377 if (PyErr_Occurred()) SWIG_fail;
10378 }
10379 Py_INCREF(Py_None); resultobj = Py_None;
10380 return resultobj;
10381 fail:
10382 return NULL;
10383 }
10384
10385
10386 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10387 PyObject *resultobj;
10388 wxString *arg1 = 0 ;
10389 wxString *arg2 = 0 ;
10390 int arg3 = (int) -1 ;
10391 wxImage *result;
10392 bool temp1 = false ;
10393 bool temp2 = false ;
10394 PyObject * obj0 = 0 ;
10395 PyObject * obj1 = 0 ;
10396 PyObject * obj2 = 0 ;
10397 char *kwnames[] = {
10398 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10399 };
10400
10401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10402 {
10403 arg1 = wxString_in_helper(obj0);
10404 if (arg1 == NULL) SWIG_fail;
10405 temp1 = true;
10406 }
10407 {
10408 arg2 = wxString_in_helper(obj1);
10409 if (arg2 == NULL) SWIG_fail;
10410 temp2 = true;
10411 }
10412 if (obj2) {
10413 {
10414 arg3 = (int)(SWIG_As_int(obj2));
10415 if (SWIG_arg_fail(3)) SWIG_fail;
10416 }
10417 }
10418 {
10419 PyThreadState* __tstate = wxPyBeginAllowThreads();
10420 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10421
10422 wxPyEndAllowThreads(__tstate);
10423 if (PyErr_Occurred()) SWIG_fail;
10424 }
10425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10426 {
10427 if (temp1)
10428 delete arg1;
10429 }
10430 {
10431 if (temp2)
10432 delete arg2;
10433 }
10434 return resultobj;
10435 fail:
10436 {
10437 if (temp1)
10438 delete arg1;
10439 }
10440 {
10441 if (temp2)
10442 delete arg2;
10443 }
10444 return NULL;
10445 }
10446
10447
10448 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10449 PyObject *resultobj;
10450 wxInputStream *arg1 = 0 ;
10451 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10452 int arg3 = (int) -1 ;
10453 wxImage *result;
10454 wxPyInputStream *temp1 ;
10455 bool created1 ;
10456 PyObject * obj0 = 0 ;
10457 PyObject * obj1 = 0 ;
10458 PyObject * obj2 = 0 ;
10459 char *kwnames[] = {
10460 (char *) "stream",(char *) "type",(char *) "index", NULL
10461 };
10462
10463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10464 {
10465 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10466 arg1 = temp1->m_wxis;
10467 created1 = false;
10468 } else {
10469 PyErr_Clear(); // clear the failure of the wxPyConvert above
10470 arg1 = wxPyCBInputStream_create(obj0, false);
10471 if (arg1 == NULL) {
10472 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10473 SWIG_fail;
10474 }
10475 created1 = true;
10476 }
10477 }
10478 if (obj1) {
10479 {
10480 arg2 = (long)(SWIG_As_long(obj1));
10481 if (SWIG_arg_fail(2)) SWIG_fail;
10482 }
10483 }
10484 if (obj2) {
10485 {
10486 arg3 = (int)(SWIG_As_int(obj2));
10487 if (SWIG_arg_fail(3)) SWIG_fail;
10488 }
10489 }
10490 {
10491 PyThreadState* __tstate = wxPyBeginAllowThreads();
10492 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10493
10494 wxPyEndAllowThreads(__tstate);
10495 if (PyErr_Occurred()) SWIG_fail;
10496 }
10497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10498 {
10499 if (created1)
10500 delete arg1;
10501 }
10502 return resultobj;
10503 fail:
10504 {
10505 if (created1)
10506 delete arg1;
10507 }
10508 return NULL;
10509 }
10510
10511
10512 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10513 PyObject *resultobj;
10514 wxInputStream *arg1 = 0 ;
10515 wxString *arg2 = 0 ;
10516 int arg3 = (int) -1 ;
10517 wxImage *result;
10518 wxPyInputStream *temp1 ;
10519 bool created1 ;
10520 bool temp2 = false ;
10521 PyObject * obj0 = 0 ;
10522 PyObject * obj1 = 0 ;
10523 PyObject * obj2 = 0 ;
10524 char *kwnames[] = {
10525 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10526 };
10527
10528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10529 {
10530 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10531 arg1 = temp1->m_wxis;
10532 created1 = false;
10533 } else {
10534 PyErr_Clear(); // clear the failure of the wxPyConvert above
10535 arg1 = wxPyCBInputStream_create(obj0, false);
10536 if (arg1 == NULL) {
10537 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10538 SWIG_fail;
10539 }
10540 created1 = true;
10541 }
10542 }
10543 {
10544 arg2 = wxString_in_helper(obj1);
10545 if (arg2 == NULL) SWIG_fail;
10546 temp2 = true;
10547 }
10548 if (obj2) {
10549 {
10550 arg3 = (int)(SWIG_As_int(obj2));
10551 if (SWIG_arg_fail(3)) SWIG_fail;
10552 }
10553 }
10554 {
10555 PyThreadState* __tstate = wxPyBeginAllowThreads();
10556 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10557
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10562 {
10563 if (created1)
10564 delete arg1;
10565 }
10566 {
10567 if (temp2)
10568 delete arg2;
10569 }
10570 return resultobj;
10571 fail:
10572 {
10573 if (created1)
10574 delete arg1;
10575 }
10576 {
10577 if (temp2)
10578 delete arg2;
10579 }
10580 return NULL;
10581 }
10582
10583
10584 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj;
10586 int arg1 = (int) 0 ;
10587 int arg2 = (int) 0 ;
10588 bool arg3 = (bool) true ;
10589 wxImage *result;
10590 PyObject * obj0 = 0 ;
10591 PyObject * obj1 = 0 ;
10592 PyObject * obj2 = 0 ;
10593 char *kwnames[] = {
10594 (char *) "width",(char *) "height",(char *) "clear", NULL
10595 };
10596
10597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10598 if (obj0) {
10599 {
10600 arg1 = (int)(SWIG_As_int(obj0));
10601 if (SWIG_arg_fail(1)) SWIG_fail;
10602 }
10603 }
10604 if (obj1) {
10605 {
10606 arg2 = (int)(SWIG_As_int(obj1));
10607 if (SWIG_arg_fail(2)) SWIG_fail;
10608 }
10609 }
10610 if (obj2) {
10611 {
10612 arg3 = (bool)(SWIG_As_bool(obj2));
10613 if (SWIG_arg_fail(3)) SWIG_fail;
10614 }
10615 }
10616 {
10617 PyThreadState* __tstate = wxPyBeginAllowThreads();
10618 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10619
10620 wxPyEndAllowThreads(__tstate);
10621 if (PyErr_Occurred()) SWIG_fail;
10622 }
10623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10624 return resultobj;
10625 fail:
10626 return NULL;
10627 }
10628
10629
10630 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10631 PyObject *resultobj;
10632 wxBitmap *arg1 = 0 ;
10633 wxImage *result;
10634 PyObject * obj0 = 0 ;
10635 char *kwnames[] = {
10636 (char *) "bitmap", NULL
10637 };
10638
10639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10640 {
10641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10642 if (SWIG_arg_fail(1)) SWIG_fail;
10643 if (arg1 == NULL) {
10644 SWIG_null_ref("wxBitmap");
10645 }
10646 if (SWIG_arg_fail(1)) SWIG_fail;
10647 }
10648 {
10649 if (!wxPyCheckForApp()) SWIG_fail;
10650 PyThreadState* __tstate = wxPyBeginAllowThreads();
10651 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10652
10653 wxPyEndAllowThreads(__tstate);
10654 if (PyErr_Occurred()) SWIG_fail;
10655 }
10656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10657 return resultobj;
10658 fail:
10659 return NULL;
10660 }
10661
10662
10663 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10664 PyObject *resultobj;
10665 int arg1 ;
10666 int arg2 ;
10667 unsigned char *arg3 = (unsigned char *) 0 ;
10668 wxImage *result;
10669 PyObject * obj0 = 0 ;
10670 PyObject * obj1 = 0 ;
10671 PyObject * obj2 = 0 ;
10672 char *kwnames[] = {
10673 (char *) "width",(char *) "height",(char *) "data", NULL
10674 };
10675
10676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10677 {
10678 arg1 = (int)(SWIG_As_int(obj0));
10679 if (SWIG_arg_fail(1)) SWIG_fail;
10680 }
10681 {
10682 arg2 = (int)(SWIG_As_int(obj1));
10683 if (SWIG_arg_fail(2)) SWIG_fail;
10684 }
10685 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10686 if (SWIG_arg_fail(3)) SWIG_fail;
10687 {
10688 PyThreadState* __tstate = wxPyBeginAllowThreads();
10689 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10690
10691 wxPyEndAllowThreads(__tstate);
10692 if (PyErr_Occurred()) SWIG_fail;
10693 }
10694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10695 return resultobj;
10696 fail:
10697 return NULL;
10698 }
10699
10700
10701 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10702 PyObject *resultobj;
10703 int arg1 ;
10704 int arg2 ;
10705 unsigned char *arg3 = (unsigned char *) 0 ;
10706 unsigned char *arg4 = (unsigned char *) 0 ;
10707 wxImage *result;
10708 PyObject * obj0 = 0 ;
10709 PyObject * obj1 = 0 ;
10710 PyObject * obj2 = 0 ;
10711 PyObject * obj3 = 0 ;
10712 char *kwnames[] = {
10713 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10714 };
10715
10716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10717 {
10718 arg1 = (int)(SWIG_As_int(obj0));
10719 if (SWIG_arg_fail(1)) SWIG_fail;
10720 }
10721 {
10722 arg2 = (int)(SWIG_As_int(obj1));
10723 if (SWIG_arg_fail(2)) SWIG_fail;
10724 }
10725 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10726 if (SWIG_arg_fail(3)) SWIG_fail;
10727 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10728 if (SWIG_arg_fail(4)) SWIG_fail;
10729 {
10730 PyThreadState* __tstate = wxPyBeginAllowThreads();
10731 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10732
10733 wxPyEndAllowThreads(__tstate);
10734 if (PyErr_Occurred()) SWIG_fail;
10735 }
10736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10737 return resultobj;
10738 fail:
10739 return NULL;
10740 }
10741
10742
10743 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10744 PyObject *resultobj;
10745 wxImage *arg1 = (wxImage *) 0 ;
10746 int arg2 ;
10747 int arg3 ;
10748 PyObject * obj0 = 0 ;
10749 PyObject * obj1 = 0 ;
10750 PyObject * obj2 = 0 ;
10751 char *kwnames[] = {
10752 (char *) "self",(char *) "width",(char *) "height", NULL
10753 };
10754
10755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10757 if (SWIG_arg_fail(1)) SWIG_fail;
10758 {
10759 arg2 = (int)(SWIG_As_int(obj1));
10760 if (SWIG_arg_fail(2)) SWIG_fail;
10761 }
10762 {
10763 arg3 = (int)(SWIG_As_int(obj2));
10764 if (SWIG_arg_fail(3)) SWIG_fail;
10765 }
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 (arg1)->Create(arg2,arg3);
10769
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 Py_INCREF(Py_None); resultobj = Py_None;
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10781 PyObject *resultobj;
10782 wxImage *arg1 = (wxImage *) 0 ;
10783 PyObject * obj0 = 0 ;
10784 char *kwnames[] = {
10785 (char *) "self", NULL
10786 };
10787
10788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10790 if (SWIG_arg_fail(1)) SWIG_fail;
10791 {
10792 PyThreadState* __tstate = wxPyBeginAllowThreads();
10793 (arg1)->Destroy();
10794
10795 wxPyEndAllowThreads(__tstate);
10796 if (PyErr_Occurred()) SWIG_fail;
10797 }
10798 Py_INCREF(Py_None); resultobj = Py_None;
10799 return resultobj;
10800 fail:
10801 return NULL;
10802 }
10803
10804
10805 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10806 PyObject *resultobj;
10807 wxImage *arg1 = (wxImage *) 0 ;
10808 int arg2 ;
10809 int arg3 ;
10810 SwigValueWrapper<wxImage > result;
10811 PyObject * obj0 = 0 ;
10812 PyObject * obj1 = 0 ;
10813 PyObject * obj2 = 0 ;
10814 char *kwnames[] = {
10815 (char *) "self",(char *) "width",(char *) "height", NULL
10816 };
10817
10818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10820 if (SWIG_arg_fail(1)) SWIG_fail;
10821 {
10822 arg2 = (int)(SWIG_As_int(obj1));
10823 if (SWIG_arg_fail(2)) SWIG_fail;
10824 }
10825 {
10826 arg3 = (int)(SWIG_As_int(obj2));
10827 if (SWIG_arg_fail(3)) SWIG_fail;
10828 }
10829 {
10830 PyThreadState* __tstate = wxPyBeginAllowThreads();
10831 result = (arg1)->Scale(arg2,arg3);
10832
10833 wxPyEndAllowThreads(__tstate);
10834 if (PyErr_Occurred()) SWIG_fail;
10835 }
10836 {
10837 wxImage * resultptr;
10838 resultptr = new wxImage((wxImage &)(result));
10839 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10840 }
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj;
10849 wxImage *arg1 = (wxImage *) 0 ;
10850 int arg2 ;
10851 int arg3 ;
10852 SwigValueWrapper<wxImage > result;
10853 PyObject * obj0 = 0 ;
10854 PyObject * obj1 = 0 ;
10855 PyObject * obj2 = 0 ;
10856 char *kwnames[] = {
10857 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10858 };
10859
10860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10862 if (SWIG_arg_fail(1)) SWIG_fail;
10863 {
10864 arg2 = (int)(SWIG_As_int(obj1));
10865 if (SWIG_arg_fail(2)) SWIG_fail;
10866 }
10867 {
10868 arg3 = (int)(SWIG_As_int(obj2));
10869 if (SWIG_arg_fail(3)) SWIG_fail;
10870 }
10871 {
10872 PyThreadState* __tstate = wxPyBeginAllowThreads();
10873 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10874
10875 wxPyEndAllowThreads(__tstate);
10876 if (PyErr_Occurred()) SWIG_fail;
10877 }
10878 {
10879 wxImage * resultptr;
10880 resultptr = new wxImage((wxImage &)(result));
10881 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10882 }
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj;
10891 wxImage *arg1 = (wxImage *) 0 ;
10892 int arg2 ;
10893 int arg3 ;
10894 wxImage *result;
10895 PyObject * obj0 = 0 ;
10896 PyObject * obj1 = 0 ;
10897 PyObject * obj2 = 0 ;
10898 char *kwnames[] = {
10899 (char *) "self",(char *) "width",(char *) "height", NULL
10900 };
10901
10902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10904 if (SWIG_arg_fail(1)) SWIG_fail;
10905 {
10906 arg2 = (int)(SWIG_As_int(obj1));
10907 if (SWIG_arg_fail(2)) SWIG_fail;
10908 }
10909 {
10910 arg3 = (int)(SWIG_As_int(obj2));
10911 if (SWIG_arg_fail(3)) SWIG_fail;
10912 }
10913 {
10914 PyThreadState* __tstate = wxPyBeginAllowThreads();
10915 {
10916 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10917 result = (wxImage *) &_result_ref;
10918 }
10919
10920 wxPyEndAllowThreads(__tstate);
10921 if (PyErr_Occurred()) SWIG_fail;
10922 }
10923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10924 return resultobj;
10925 fail:
10926 return NULL;
10927 }
10928
10929
10930 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10931 PyObject *resultobj;
10932 wxImage *arg1 = (wxImage *) 0 ;
10933 int arg2 ;
10934 int arg3 ;
10935 unsigned char arg4 ;
10936 unsigned char arg5 ;
10937 unsigned char arg6 ;
10938 PyObject * obj0 = 0 ;
10939 PyObject * obj1 = 0 ;
10940 PyObject * obj2 = 0 ;
10941 PyObject * obj3 = 0 ;
10942 PyObject * obj4 = 0 ;
10943 PyObject * obj5 = 0 ;
10944 char *kwnames[] = {
10945 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10946 };
10947
10948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10950 if (SWIG_arg_fail(1)) SWIG_fail;
10951 {
10952 arg2 = (int)(SWIG_As_int(obj1));
10953 if (SWIG_arg_fail(2)) SWIG_fail;
10954 }
10955 {
10956 arg3 = (int)(SWIG_As_int(obj2));
10957 if (SWIG_arg_fail(3)) SWIG_fail;
10958 }
10959 {
10960 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10961 if (SWIG_arg_fail(4)) SWIG_fail;
10962 }
10963 {
10964 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10965 if (SWIG_arg_fail(5)) SWIG_fail;
10966 }
10967 {
10968 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10969 if (SWIG_arg_fail(6)) SWIG_fail;
10970 }
10971 {
10972 PyThreadState* __tstate = wxPyBeginAllowThreads();
10973 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10974
10975 wxPyEndAllowThreads(__tstate);
10976 if (PyErr_Occurred()) SWIG_fail;
10977 }
10978 Py_INCREF(Py_None); resultobj = Py_None;
10979 return resultobj;
10980 fail:
10981 return NULL;
10982 }
10983
10984
10985 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10986 PyObject *resultobj;
10987 wxImage *arg1 = (wxImage *) 0 ;
10988 int arg2 ;
10989 int arg3 ;
10990 unsigned char result;
10991 PyObject * obj0 = 0 ;
10992 PyObject * obj1 = 0 ;
10993 PyObject * obj2 = 0 ;
10994 char *kwnames[] = {
10995 (char *) "self",(char *) "x",(char *) "y", NULL
10996 };
10997
10998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11000 if (SWIG_arg_fail(1)) SWIG_fail;
11001 {
11002 arg2 = (int)(SWIG_As_int(obj1));
11003 if (SWIG_arg_fail(2)) SWIG_fail;
11004 }
11005 {
11006 arg3 = (int)(SWIG_As_int(obj2));
11007 if (SWIG_arg_fail(3)) SWIG_fail;
11008 }
11009 {
11010 PyThreadState* __tstate = wxPyBeginAllowThreads();
11011 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11012
11013 wxPyEndAllowThreads(__tstate);
11014 if (PyErr_Occurred()) SWIG_fail;
11015 }
11016 {
11017 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11018 }
11019 return resultobj;
11020 fail:
11021 return NULL;
11022 }
11023
11024
11025 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11026 PyObject *resultobj;
11027 wxImage *arg1 = (wxImage *) 0 ;
11028 int arg2 ;
11029 int arg3 ;
11030 unsigned char result;
11031 PyObject * obj0 = 0 ;
11032 PyObject * obj1 = 0 ;
11033 PyObject * obj2 = 0 ;
11034 char *kwnames[] = {
11035 (char *) "self",(char *) "x",(char *) "y", NULL
11036 };
11037
11038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11040 if (SWIG_arg_fail(1)) SWIG_fail;
11041 {
11042 arg2 = (int)(SWIG_As_int(obj1));
11043 if (SWIG_arg_fail(2)) SWIG_fail;
11044 }
11045 {
11046 arg3 = (int)(SWIG_As_int(obj2));
11047 if (SWIG_arg_fail(3)) SWIG_fail;
11048 }
11049 {
11050 PyThreadState* __tstate = wxPyBeginAllowThreads();
11051 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11052
11053 wxPyEndAllowThreads(__tstate);
11054 if (PyErr_Occurred()) SWIG_fail;
11055 }
11056 {
11057 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11058 }
11059 return resultobj;
11060 fail:
11061 return NULL;
11062 }
11063
11064
11065 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11066 PyObject *resultobj;
11067 wxImage *arg1 = (wxImage *) 0 ;
11068 int arg2 ;
11069 int arg3 ;
11070 unsigned char result;
11071 PyObject * obj0 = 0 ;
11072 PyObject * obj1 = 0 ;
11073 PyObject * obj2 = 0 ;
11074 char *kwnames[] = {
11075 (char *) "self",(char *) "x",(char *) "y", NULL
11076 };
11077
11078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11080 if (SWIG_arg_fail(1)) SWIG_fail;
11081 {
11082 arg2 = (int)(SWIG_As_int(obj1));
11083 if (SWIG_arg_fail(2)) SWIG_fail;
11084 }
11085 {
11086 arg3 = (int)(SWIG_As_int(obj2));
11087 if (SWIG_arg_fail(3)) SWIG_fail;
11088 }
11089 {
11090 PyThreadState* __tstate = wxPyBeginAllowThreads();
11091 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11092
11093 wxPyEndAllowThreads(__tstate);
11094 if (PyErr_Occurred()) SWIG_fail;
11095 }
11096 {
11097 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11098 }
11099 return resultobj;
11100 fail:
11101 return NULL;
11102 }
11103
11104
11105 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11106 PyObject *resultobj;
11107 wxImage *arg1 = (wxImage *) 0 ;
11108 int arg2 ;
11109 int arg3 ;
11110 unsigned char arg4 ;
11111 PyObject * obj0 = 0 ;
11112 PyObject * obj1 = 0 ;
11113 PyObject * obj2 = 0 ;
11114 PyObject * obj3 = 0 ;
11115 char *kwnames[] = {
11116 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11117 };
11118
11119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11121 if (SWIG_arg_fail(1)) SWIG_fail;
11122 {
11123 arg2 = (int)(SWIG_As_int(obj1));
11124 if (SWIG_arg_fail(2)) SWIG_fail;
11125 }
11126 {
11127 arg3 = (int)(SWIG_As_int(obj2));
11128 if (SWIG_arg_fail(3)) SWIG_fail;
11129 }
11130 {
11131 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11132 if (SWIG_arg_fail(4)) SWIG_fail;
11133 }
11134 {
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 (arg1)->SetAlpha(arg2,arg3,arg4);
11137
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 Py_INCREF(Py_None); resultobj = Py_None;
11142 return resultobj;
11143 fail:
11144 return NULL;
11145 }
11146
11147
11148 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11149 PyObject *resultobj;
11150 wxImage *arg1 = (wxImage *) 0 ;
11151 int arg2 ;
11152 int arg3 ;
11153 unsigned char result;
11154 PyObject * obj0 = 0 ;
11155 PyObject * obj1 = 0 ;
11156 PyObject * obj2 = 0 ;
11157 char *kwnames[] = {
11158 (char *) "self",(char *) "x",(char *) "y", NULL
11159 };
11160
11161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11163 if (SWIG_arg_fail(1)) SWIG_fail;
11164 {
11165 arg2 = (int)(SWIG_As_int(obj1));
11166 if (SWIG_arg_fail(2)) SWIG_fail;
11167 }
11168 {
11169 arg3 = (int)(SWIG_As_int(obj2));
11170 if (SWIG_arg_fail(3)) SWIG_fail;
11171 }
11172 {
11173 PyThreadState* __tstate = wxPyBeginAllowThreads();
11174 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11175
11176 wxPyEndAllowThreads(__tstate);
11177 if (PyErr_Occurred()) SWIG_fail;
11178 }
11179 {
11180 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11181 }
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11189 PyObject *resultobj;
11190 wxImage *arg1 = (wxImage *) 0 ;
11191 bool result;
11192 PyObject * obj0 = 0 ;
11193 char *kwnames[] = {
11194 (char *) "self", NULL
11195 };
11196
11197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11199 if (SWIG_arg_fail(1)) SWIG_fail;
11200 {
11201 PyThreadState* __tstate = wxPyBeginAllowThreads();
11202 result = (bool)(arg1)->HasAlpha();
11203
11204 wxPyEndAllowThreads(__tstate);
11205 if (PyErr_Occurred()) SWIG_fail;
11206 }
11207 {
11208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11209 }
11210 return resultobj;
11211 fail:
11212 return NULL;
11213 }
11214
11215
11216 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11217 PyObject *resultobj;
11218 wxImage *arg1 = (wxImage *) 0 ;
11219 PyObject * obj0 = 0 ;
11220 char *kwnames[] = {
11221 (char *) "self", NULL
11222 };
11223
11224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11226 if (SWIG_arg_fail(1)) SWIG_fail;
11227 {
11228 PyThreadState* __tstate = wxPyBeginAllowThreads();
11229 (arg1)->InitAlpha();
11230
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 Py_INCREF(Py_None); resultobj = Py_None;
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11242 PyObject *resultobj;
11243 wxImage *arg1 = (wxImage *) 0 ;
11244 byte *arg2 = (byte *) 0 ;
11245 byte *arg3 = (byte *) 0 ;
11246 byte *arg4 = (byte *) 0 ;
11247 byte arg5 = (byte) 0 ;
11248 byte arg6 = (byte) 0 ;
11249 byte arg7 = (byte) 0 ;
11250 bool result;
11251 byte temp2 ;
11252 int res2 = 0 ;
11253 byte temp3 ;
11254 int res3 = 0 ;
11255 byte temp4 ;
11256 int res4 = 0 ;
11257 PyObject * obj0 = 0 ;
11258 PyObject * obj1 = 0 ;
11259 PyObject * obj2 = 0 ;
11260 PyObject * obj3 = 0 ;
11261 char *kwnames[] = {
11262 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11263 };
11264
11265 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11266 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11267 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11270 if (SWIG_arg_fail(1)) SWIG_fail;
11271 if (obj1) {
11272 {
11273 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11274 if (SWIG_arg_fail(5)) SWIG_fail;
11275 }
11276 }
11277 if (obj2) {
11278 {
11279 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11280 if (SWIG_arg_fail(6)) SWIG_fail;
11281 }
11282 }
11283 if (obj3) {
11284 {
11285 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11286 if (SWIG_arg_fail(7)) SWIG_fail;
11287 }
11288 }
11289 {
11290 PyThreadState* __tstate = wxPyBeginAllowThreads();
11291 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11292
11293 wxPyEndAllowThreads(__tstate);
11294 if (PyErr_Occurred()) SWIG_fail;
11295 }
11296 {
11297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11298 }
11299 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11300 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11301 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11302 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11303 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11304 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11305 return resultobj;
11306 fail:
11307 return NULL;
11308 }
11309
11310
11311 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11312 PyObject *resultobj;
11313 wxImage *arg1 = (wxImage *) 0 ;
11314 byte arg2 = (byte) 128 ;
11315 bool result;
11316 PyObject * obj0 = 0 ;
11317 PyObject * obj1 = 0 ;
11318 char *kwnames[] = {
11319 (char *) "self",(char *) "threshold", NULL
11320 };
11321
11322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11324 if (SWIG_arg_fail(1)) SWIG_fail;
11325 if (obj1) {
11326 {
11327 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11328 if (SWIG_arg_fail(2)) SWIG_fail;
11329 }
11330 }
11331 {
11332 PyThreadState* __tstate = wxPyBeginAllowThreads();
11333 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11334
11335 wxPyEndAllowThreads(__tstate);
11336 if (PyErr_Occurred()) SWIG_fail;
11337 }
11338 {
11339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11340 }
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11348 PyObject *resultobj;
11349 wxImage *arg1 = (wxImage *) 0 ;
11350 unsigned char arg2 ;
11351 unsigned char arg3 ;
11352 unsigned char arg4 ;
11353 bool result;
11354 PyObject * obj0 = 0 ;
11355 PyObject * obj1 = 0 ;
11356 PyObject * obj2 = 0 ;
11357 PyObject * obj3 = 0 ;
11358 char *kwnames[] = {
11359 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11360 };
11361
11362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11364 if (SWIG_arg_fail(1)) SWIG_fail;
11365 {
11366 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11367 if (SWIG_arg_fail(2)) SWIG_fail;
11368 }
11369 {
11370 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11371 if (SWIG_arg_fail(3)) SWIG_fail;
11372 }
11373 {
11374 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11375 if (SWIG_arg_fail(4)) SWIG_fail;
11376 }
11377 {
11378 PyThreadState* __tstate = wxPyBeginAllowThreads();
11379 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11380
11381 wxPyEndAllowThreads(__tstate);
11382 if (PyErr_Occurred()) SWIG_fail;
11383 }
11384 {
11385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11386 }
11387 return resultobj;
11388 fail:
11389 return NULL;
11390 }
11391
11392
11393 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11394 PyObject *resultobj;
11395 wxImage *arg1 = (wxImage *) 0 ;
11396 wxImage *arg2 = 0 ;
11397 byte arg3 ;
11398 byte arg4 ;
11399 byte arg5 ;
11400 bool result;
11401 PyObject * obj0 = 0 ;
11402 PyObject * obj1 = 0 ;
11403 PyObject * obj2 = 0 ;
11404 PyObject * obj3 = 0 ;
11405 PyObject * obj4 = 0 ;
11406 char *kwnames[] = {
11407 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11408 };
11409
11410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11412 if (SWIG_arg_fail(1)) SWIG_fail;
11413 {
11414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11415 if (SWIG_arg_fail(2)) SWIG_fail;
11416 if (arg2 == NULL) {
11417 SWIG_null_ref("wxImage");
11418 }
11419 if (SWIG_arg_fail(2)) SWIG_fail;
11420 }
11421 {
11422 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11423 if (SWIG_arg_fail(3)) SWIG_fail;
11424 }
11425 {
11426 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11427 if (SWIG_arg_fail(4)) SWIG_fail;
11428 }
11429 {
11430 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11431 if (SWIG_arg_fail(5)) SWIG_fail;
11432 }
11433 {
11434 PyThreadState* __tstate = wxPyBeginAllowThreads();
11435 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11436
11437 wxPyEndAllowThreads(__tstate);
11438 if (PyErr_Occurred()) SWIG_fail;
11439 }
11440 {
11441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11442 }
11443 return resultobj;
11444 fail:
11445 return NULL;
11446 }
11447
11448
11449 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11450 PyObject *resultobj;
11451 wxString *arg1 = 0 ;
11452 bool result;
11453 bool temp1 = false ;
11454 PyObject * obj0 = 0 ;
11455 char *kwnames[] = {
11456 (char *) "name", NULL
11457 };
11458
11459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11460 {
11461 arg1 = wxString_in_helper(obj0);
11462 if (arg1 == NULL) SWIG_fail;
11463 temp1 = true;
11464 }
11465 {
11466 PyThreadState* __tstate = wxPyBeginAllowThreads();
11467 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11468
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 {
11473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11474 }
11475 {
11476 if (temp1)
11477 delete arg1;
11478 }
11479 return resultobj;
11480 fail:
11481 {
11482 if (temp1)
11483 delete arg1;
11484 }
11485 return NULL;
11486 }
11487
11488
11489 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11490 PyObject *resultobj;
11491 wxString *arg1 = 0 ;
11492 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11493 int result;
11494 bool temp1 = false ;
11495 PyObject * obj0 = 0 ;
11496 PyObject * obj1 = 0 ;
11497 char *kwnames[] = {
11498 (char *) "name",(char *) "type", NULL
11499 };
11500
11501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11502 {
11503 arg1 = wxString_in_helper(obj0);
11504 if (arg1 == NULL) SWIG_fail;
11505 temp1 = true;
11506 }
11507 if (obj1) {
11508 {
11509 arg2 = (long)(SWIG_As_long(obj1));
11510 if (SWIG_arg_fail(2)) SWIG_fail;
11511 }
11512 }
11513 {
11514 PyThreadState* __tstate = wxPyBeginAllowThreads();
11515 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11516
11517 wxPyEndAllowThreads(__tstate);
11518 if (PyErr_Occurred()) SWIG_fail;
11519 }
11520 {
11521 resultobj = SWIG_From_int((int)(result));
11522 }
11523 {
11524 if (temp1)
11525 delete arg1;
11526 }
11527 return resultobj;
11528 fail:
11529 {
11530 if (temp1)
11531 delete arg1;
11532 }
11533 return NULL;
11534 }
11535
11536
11537 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11538 PyObject *resultobj;
11539 wxImage *arg1 = (wxImage *) 0 ;
11540 wxString *arg2 = 0 ;
11541 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11542 int arg4 = (int) -1 ;
11543 bool result;
11544 bool temp2 = false ;
11545 PyObject * obj0 = 0 ;
11546 PyObject * obj1 = 0 ;
11547 PyObject * obj2 = 0 ;
11548 PyObject * obj3 = 0 ;
11549 char *kwnames[] = {
11550 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11551 };
11552
11553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11555 if (SWIG_arg_fail(1)) SWIG_fail;
11556 {
11557 arg2 = wxString_in_helper(obj1);
11558 if (arg2 == NULL) SWIG_fail;
11559 temp2 = true;
11560 }
11561 if (obj2) {
11562 {
11563 arg3 = (long)(SWIG_As_long(obj2));
11564 if (SWIG_arg_fail(3)) SWIG_fail;
11565 }
11566 }
11567 if (obj3) {
11568 {
11569 arg4 = (int)(SWIG_As_int(obj3));
11570 if (SWIG_arg_fail(4)) SWIG_fail;
11571 }
11572 }
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11576
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 {
11581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11582 }
11583 {
11584 if (temp2)
11585 delete arg2;
11586 }
11587 return resultobj;
11588 fail:
11589 {
11590 if (temp2)
11591 delete arg2;
11592 }
11593 return NULL;
11594 }
11595
11596
11597 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11598 PyObject *resultobj;
11599 wxImage *arg1 = (wxImage *) 0 ;
11600 wxString *arg2 = 0 ;
11601 wxString *arg3 = 0 ;
11602 int arg4 = (int) -1 ;
11603 bool result;
11604 bool temp2 = false ;
11605 bool temp3 = false ;
11606 PyObject * obj0 = 0 ;
11607 PyObject * obj1 = 0 ;
11608 PyObject * obj2 = 0 ;
11609 PyObject * obj3 = 0 ;
11610 char *kwnames[] = {
11611 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11612 };
11613
11614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11616 if (SWIG_arg_fail(1)) SWIG_fail;
11617 {
11618 arg2 = wxString_in_helper(obj1);
11619 if (arg2 == NULL) SWIG_fail;
11620 temp2 = true;
11621 }
11622 {
11623 arg3 = wxString_in_helper(obj2);
11624 if (arg3 == NULL) SWIG_fail;
11625 temp3 = true;
11626 }
11627 if (obj3) {
11628 {
11629 arg4 = (int)(SWIG_As_int(obj3));
11630 if (SWIG_arg_fail(4)) SWIG_fail;
11631 }
11632 }
11633 {
11634 PyThreadState* __tstate = wxPyBeginAllowThreads();
11635 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11636
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 {
11641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11642 }
11643 {
11644 if (temp2)
11645 delete arg2;
11646 }
11647 {
11648 if (temp3)
11649 delete arg3;
11650 }
11651 return resultobj;
11652 fail:
11653 {
11654 if (temp2)
11655 delete arg2;
11656 }
11657 {
11658 if (temp3)
11659 delete arg3;
11660 }
11661 return NULL;
11662 }
11663
11664
11665 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11666 PyObject *resultobj;
11667 wxImage *arg1 = (wxImage *) 0 ;
11668 wxString *arg2 = 0 ;
11669 int arg3 ;
11670 bool result;
11671 bool temp2 = false ;
11672 PyObject * obj0 = 0 ;
11673 PyObject * obj1 = 0 ;
11674 PyObject * obj2 = 0 ;
11675 char *kwnames[] = {
11676 (char *) "self",(char *) "name",(char *) "type", NULL
11677 };
11678
11679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11681 if (SWIG_arg_fail(1)) SWIG_fail;
11682 {
11683 arg2 = wxString_in_helper(obj1);
11684 if (arg2 == NULL) SWIG_fail;
11685 temp2 = true;
11686 }
11687 {
11688 arg3 = (int)(SWIG_As_int(obj2));
11689 if (SWIG_arg_fail(3)) SWIG_fail;
11690 }
11691 {
11692 PyThreadState* __tstate = wxPyBeginAllowThreads();
11693 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11694
11695 wxPyEndAllowThreads(__tstate);
11696 if (PyErr_Occurred()) SWIG_fail;
11697 }
11698 {
11699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11700 }
11701 {
11702 if (temp2)
11703 delete arg2;
11704 }
11705 return resultobj;
11706 fail:
11707 {
11708 if (temp2)
11709 delete arg2;
11710 }
11711 return NULL;
11712 }
11713
11714
11715 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11716 PyObject *resultobj;
11717 wxImage *arg1 = (wxImage *) 0 ;
11718 wxString *arg2 = 0 ;
11719 wxString *arg3 = 0 ;
11720 bool result;
11721 bool temp2 = false ;
11722 bool temp3 = false ;
11723 PyObject * obj0 = 0 ;
11724 PyObject * obj1 = 0 ;
11725 PyObject * obj2 = 0 ;
11726 char *kwnames[] = {
11727 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11728 };
11729
11730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11732 if (SWIG_arg_fail(1)) SWIG_fail;
11733 {
11734 arg2 = wxString_in_helper(obj1);
11735 if (arg2 == NULL) SWIG_fail;
11736 temp2 = true;
11737 }
11738 {
11739 arg3 = wxString_in_helper(obj2);
11740 if (arg3 == NULL) SWIG_fail;
11741 temp3 = true;
11742 }
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11746
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 {
11751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11752 }
11753 {
11754 if (temp2)
11755 delete arg2;
11756 }
11757 {
11758 if (temp3)
11759 delete arg3;
11760 }
11761 return resultobj;
11762 fail:
11763 {
11764 if (temp2)
11765 delete arg2;
11766 }
11767 {
11768 if (temp3)
11769 delete arg3;
11770 }
11771 return NULL;
11772 }
11773
11774
11775 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11776 PyObject *resultobj;
11777 wxInputStream *arg1 = 0 ;
11778 bool result;
11779 wxPyInputStream *temp1 ;
11780 bool created1 ;
11781 PyObject * obj0 = 0 ;
11782 char *kwnames[] = {
11783 (char *) "stream", NULL
11784 };
11785
11786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11787 {
11788 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11789 arg1 = temp1->m_wxis;
11790 created1 = false;
11791 } else {
11792 PyErr_Clear(); // clear the failure of the wxPyConvert above
11793 arg1 = wxPyCBInputStream_create(obj0, false);
11794 if (arg1 == NULL) {
11795 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11796 SWIG_fail;
11797 }
11798 created1 = true;
11799 }
11800 }
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 result = (bool)wxImage::CanRead(*arg1);
11804
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 {
11809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11810 }
11811 {
11812 if (created1)
11813 delete arg1;
11814 }
11815 return resultobj;
11816 fail:
11817 {
11818 if (created1)
11819 delete arg1;
11820 }
11821 return NULL;
11822 }
11823
11824
11825 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11826 PyObject *resultobj;
11827 wxImage *arg1 = (wxImage *) 0 ;
11828 wxInputStream *arg2 = 0 ;
11829 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11830 int arg4 = (int) -1 ;
11831 bool result;
11832 wxPyInputStream *temp2 ;
11833 bool created2 ;
11834 PyObject * obj0 = 0 ;
11835 PyObject * obj1 = 0 ;
11836 PyObject * obj2 = 0 ;
11837 PyObject * obj3 = 0 ;
11838 char *kwnames[] = {
11839 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11840 };
11841
11842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11844 if (SWIG_arg_fail(1)) SWIG_fail;
11845 {
11846 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11847 arg2 = temp2->m_wxis;
11848 created2 = false;
11849 } else {
11850 PyErr_Clear(); // clear the failure of the wxPyConvert above
11851 arg2 = wxPyCBInputStream_create(obj1, false);
11852 if (arg2 == NULL) {
11853 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11854 SWIG_fail;
11855 }
11856 created2 = true;
11857 }
11858 }
11859 if (obj2) {
11860 {
11861 arg3 = (long)(SWIG_As_long(obj2));
11862 if (SWIG_arg_fail(3)) SWIG_fail;
11863 }
11864 }
11865 if (obj3) {
11866 {
11867 arg4 = (int)(SWIG_As_int(obj3));
11868 if (SWIG_arg_fail(4)) SWIG_fail;
11869 }
11870 }
11871 {
11872 PyThreadState* __tstate = wxPyBeginAllowThreads();
11873 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11874
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11880 }
11881 {
11882 if (created2)
11883 delete arg2;
11884 }
11885 return resultobj;
11886 fail:
11887 {
11888 if (created2)
11889 delete arg2;
11890 }
11891 return NULL;
11892 }
11893
11894
11895 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11896 PyObject *resultobj;
11897 wxImage *arg1 = (wxImage *) 0 ;
11898 wxInputStream *arg2 = 0 ;
11899 wxString *arg3 = 0 ;
11900 int arg4 = (int) -1 ;
11901 bool result;
11902 wxPyInputStream *temp2 ;
11903 bool created2 ;
11904 bool temp3 = false ;
11905 PyObject * obj0 = 0 ;
11906 PyObject * obj1 = 0 ;
11907 PyObject * obj2 = 0 ;
11908 PyObject * obj3 = 0 ;
11909 char *kwnames[] = {
11910 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11911 };
11912
11913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11915 if (SWIG_arg_fail(1)) SWIG_fail;
11916 {
11917 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11918 arg2 = temp2->m_wxis;
11919 created2 = false;
11920 } else {
11921 PyErr_Clear(); // clear the failure of the wxPyConvert above
11922 arg2 = wxPyCBInputStream_create(obj1, false);
11923 if (arg2 == NULL) {
11924 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11925 SWIG_fail;
11926 }
11927 created2 = true;
11928 }
11929 }
11930 {
11931 arg3 = wxString_in_helper(obj2);
11932 if (arg3 == NULL) SWIG_fail;
11933 temp3 = true;
11934 }
11935 if (obj3) {
11936 {
11937 arg4 = (int)(SWIG_As_int(obj3));
11938 if (SWIG_arg_fail(4)) SWIG_fail;
11939 }
11940 }
11941 {
11942 PyThreadState* __tstate = wxPyBeginAllowThreads();
11943 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11944
11945 wxPyEndAllowThreads(__tstate);
11946 if (PyErr_Occurred()) SWIG_fail;
11947 }
11948 {
11949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11950 }
11951 {
11952 if (created2)
11953 delete arg2;
11954 }
11955 {
11956 if (temp3)
11957 delete arg3;
11958 }
11959 return resultobj;
11960 fail:
11961 {
11962 if (created2)
11963 delete arg2;
11964 }
11965 {
11966 if (temp3)
11967 delete arg3;
11968 }
11969 return NULL;
11970 }
11971
11972
11973 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11974 PyObject *resultobj;
11975 wxImage *arg1 = (wxImage *) 0 ;
11976 bool result;
11977 PyObject * obj0 = 0 ;
11978 char *kwnames[] = {
11979 (char *) "self", NULL
11980 };
11981
11982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11984 if (SWIG_arg_fail(1)) SWIG_fail;
11985 {
11986 PyThreadState* __tstate = wxPyBeginAllowThreads();
11987 result = (bool)(arg1)->Ok();
11988
11989 wxPyEndAllowThreads(__tstate);
11990 if (PyErr_Occurred()) SWIG_fail;
11991 }
11992 {
11993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11994 }
11995 return resultobj;
11996 fail:
11997 return NULL;
11998 }
11999
12000
12001 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12002 PyObject *resultobj;
12003 wxImage *arg1 = (wxImage *) 0 ;
12004 int result;
12005 PyObject * obj0 = 0 ;
12006 char *kwnames[] = {
12007 (char *) "self", NULL
12008 };
12009
12010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12012 if (SWIG_arg_fail(1)) SWIG_fail;
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 result = (int)(arg1)->GetWidth();
12016
12017 wxPyEndAllowThreads(__tstate);
12018 if (PyErr_Occurred()) SWIG_fail;
12019 }
12020 {
12021 resultobj = SWIG_From_int((int)(result));
12022 }
12023 return resultobj;
12024 fail:
12025 return NULL;
12026 }
12027
12028
12029 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12030 PyObject *resultobj;
12031 wxImage *arg1 = (wxImage *) 0 ;
12032 int result;
12033 PyObject * obj0 = 0 ;
12034 char *kwnames[] = {
12035 (char *) "self", NULL
12036 };
12037
12038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12040 if (SWIG_arg_fail(1)) SWIG_fail;
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 result = (int)(arg1)->GetHeight();
12044
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 {
12049 resultobj = SWIG_From_int((int)(result));
12050 }
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj;
12059 wxImage *arg1 = (wxImage *) 0 ;
12060 wxSize result;
12061 PyObject * obj0 = 0 ;
12062 char *kwnames[] = {
12063 (char *) "self", NULL
12064 };
12065
12066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12068 if (SWIG_arg_fail(1)) SWIG_fail;
12069 {
12070 PyThreadState* __tstate = wxPyBeginAllowThreads();
12071 result = wxImage_GetSize(arg1);
12072
12073 wxPyEndAllowThreads(__tstate);
12074 if (PyErr_Occurred()) SWIG_fail;
12075 }
12076 {
12077 wxSize * resultptr;
12078 resultptr = new wxSize((wxSize &)(result));
12079 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12080 }
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj;
12089 wxImage *arg1 = (wxImage *) 0 ;
12090 wxRect *arg2 = 0 ;
12091 SwigValueWrapper<wxImage > result;
12092 wxRect temp2 ;
12093 PyObject * obj0 = 0 ;
12094 PyObject * obj1 = 0 ;
12095 char *kwnames[] = {
12096 (char *) "self",(char *) "rect", NULL
12097 };
12098
12099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
12104 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12105 }
12106 {
12107 PyThreadState* __tstate = wxPyBeginAllowThreads();
12108 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12109
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 {
12114 wxImage * resultptr;
12115 resultptr = new wxImage((wxImage &)(result));
12116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12117 }
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12125 PyObject *resultobj;
12126 wxImage *arg1 = (wxImage *) 0 ;
12127 SwigValueWrapper<wxImage > result;
12128 PyObject * obj0 = 0 ;
12129 char *kwnames[] = {
12130 (char *) "self", NULL
12131 };
12132
12133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(1)) SWIG_fail;
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (arg1)->Copy();
12139
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 {
12144 wxImage * resultptr;
12145 resultptr = new wxImage((wxImage &)(result));
12146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12147 }
12148 return resultobj;
12149 fail:
12150 return NULL;
12151 }
12152
12153
12154 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12155 PyObject *resultobj;
12156 wxImage *arg1 = (wxImage *) 0 ;
12157 wxImage *arg2 = 0 ;
12158 int arg3 ;
12159 int arg4 ;
12160 PyObject * obj0 = 0 ;
12161 PyObject * obj1 = 0 ;
12162 PyObject * obj2 = 0 ;
12163 PyObject * obj3 = 0 ;
12164 char *kwnames[] = {
12165 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12166 };
12167
12168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12170 if (SWIG_arg_fail(1)) SWIG_fail;
12171 {
12172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12173 if (SWIG_arg_fail(2)) SWIG_fail;
12174 if (arg2 == NULL) {
12175 SWIG_null_ref("wxImage");
12176 }
12177 if (SWIG_arg_fail(2)) SWIG_fail;
12178 }
12179 {
12180 arg3 = (int)(SWIG_As_int(obj2));
12181 if (SWIG_arg_fail(3)) SWIG_fail;
12182 }
12183 {
12184 arg4 = (int)(SWIG_As_int(obj3));
12185 if (SWIG_arg_fail(4)) SWIG_fail;
12186 }
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12190
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 Py_INCREF(Py_None); resultobj = Py_None;
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12202 PyObject *resultobj;
12203 wxImage *arg1 = (wxImage *) 0 ;
12204 PyObject *result;
12205 PyObject * obj0 = 0 ;
12206 char *kwnames[] = {
12207 (char *) "self", NULL
12208 };
12209
12210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12212 if (SWIG_arg_fail(1)) SWIG_fail;
12213 {
12214 PyThreadState* __tstate = wxPyBeginAllowThreads();
12215 result = (PyObject *)wxImage_GetData(arg1);
12216
12217 wxPyEndAllowThreads(__tstate);
12218 if (PyErr_Occurred()) SWIG_fail;
12219 }
12220 resultobj = result;
12221 return resultobj;
12222 fail:
12223 return NULL;
12224 }
12225
12226
12227 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12228 PyObject *resultobj;
12229 wxImage *arg1 = (wxImage *) 0 ;
12230 PyObject *arg2 = (PyObject *) 0 ;
12231 PyObject * obj0 = 0 ;
12232 PyObject * obj1 = 0 ;
12233 char *kwnames[] = {
12234 (char *) "self",(char *) "data", NULL
12235 };
12236
12237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12239 if (SWIG_arg_fail(1)) SWIG_fail;
12240 arg2 = obj1;
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 wxImage_SetData(arg1,arg2);
12244
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 Py_INCREF(Py_None); resultobj = Py_None;
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj;
12257 wxImage *arg1 = (wxImage *) 0 ;
12258 PyObject *result;
12259 PyObject * obj0 = 0 ;
12260 char *kwnames[] = {
12261 (char *) "self", NULL
12262 };
12263
12264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12266 if (SWIG_arg_fail(1)) SWIG_fail;
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12270
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 resultobj = result;
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj;
12283 wxImage *arg1 = (wxImage *) 0 ;
12284 PyObject *arg2 = (PyObject *) 0 ;
12285 PyObject * obj0 = 0 ;
12286 PyObject * obj1 = 0 ;
12287 char *kwnames[] = {
12288 (char *) "self",(char *) "data", NULL
12289 };
12290
12291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12293 if (SWIG_arg_fail(1)) SWIG_fail;
12294 arg2 = obj1;
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 wxImage_SetDataBuffer(arg1,arg2);
12298
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 Py_INCREF(Py_None); resultobj = Py_None;
12303 return resultobj;
12304 fail:
12305 return NULL;
12306 }
12307
12308
12309 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12310 PyObject *resultobj;
12311 wxImage *arg1 = (wxImage *) 0 ;
12312 PyObject *result;
12313 PyObject * obj0 = 0 ;
12314 char *kwnames[] = {
12315 (char *) "self", NULL
12316 };
12317
12318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12320 if (SWIG_arg_fail(1)) SWIG_fail;
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 result = (PyObject *)wxImage_GetAlphaData(arg1);
12324
12325 wxPyEndAllowThreads(__tstate);
12326 if (PyErr_Occurred()) SWIG_fail;
12327 }
12328 resultobj = result;
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12336 PyObject *resultobj;
12337 wxImage *arg1 = (wxImage *) 0 ;
12338 PyObject *arg2 = (PyObject *) 0 ;
12339 PyObject * obj0 = 0 ;
12340 PyObject * obj1 = 0 ;
12341 char *kwnames[] = {
12342 (char *) "self",(char *) "data", NULL
12343 };
12344
12345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12347 if (SWIG_arg_fail(1)) SWIG_fail;
12348 arg2 = obj1;
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 wxImage_SetAlphaData(arg1,arg2);
12352
12353 wxPyEndAllowThreads(__tstate);
12354 if (PyErr_Occurred()) SWIG_fail;
12355 }
12356 Py_INCREF(Py_None); resultobj = Py_None;
12357 return resultobj;
12358 fail:
12359 return NULL;
12360 }
12361
12362
12363 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12364 PyObject *resultobj;
12365 wxImage *arg1 = (wxImage *) 0 ;
12366 PyObject *result;
12367 PyObject * obj0 = 0 ;
12368 char *kwnames[] = {
12369 (char *) "self", NULL
12370 };
12371
12372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12374 if (SWIG_arg_fail(1)) SWIG_fail;
12375 {
12376 PyThreadState* __tstate = wxPyBeginAllowThreads();
12377 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12378
12379 wxPyEndAllowThreads(__tstate);
12380 if (PyErr_Occurred()) SWIG_fail;
12381 }
12382 resultobj = result;
12383 return resultobj;
12384 fail:
12385 return NULL;
12386 }
12387
12388
12389 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12390 PyObject *resultobj;
12391 wxImage *arg1 = (wxImage *) 0 ;
12392 PyObject *arg2 = (PyObject *) 0 ;
12393 PyObject * obj0 = 0 ;
12394 PyObject * obj1 = 0 ;
12395 char *kwnames[] = {
12396 (char *) "self",(char *) "data", NULL
12397 };
12398
12399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12401 if (SWIG_arg_fail(1)) SWIG_fail;
12402 arg2 = obj1;
12403 {
12404 PyThreadState* __tstate = wxPyBeginAllowThreads();
12405 wxImage_SetAlphaBuffer(arg1,arg2);
12406
12407 wxPyEndAllowThreads(__tstate);
12408 if (PyErr_Occurred()) SWIG_fail;
12409 }
12410 Py_INCREF(Py_None); resultobj = Py_None;
12411 return resultobj;
12412 fail:
12413 return NULL;
12414 }
12415
12416
12417 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12418 PyObject *resultobj;
12419 wxImage *arg1 = (wxImage *) 0 ;
12420 unsigned char arg2 ;
12421 unsigned char arg3 ;
12422 unsigned char arg4 ;
12423 PyObject * obj0 = 0 ;
12424 PyObject * obj1 = 0 ;
12425 PyObject * obj2 = 0 ;
12426 PyObject * obj3 = 0 ;
12427 char *kwnames[] = {
12428 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12429 };
12430
12431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12433 if (SWIG_arg_fail(1)) SWIG_fail;
12434 {
12435 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12436 if (SWIG_arg_fail(2)) SWIG_fail;
12437 }
12438 {
12439 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12440 if (SWIG_arg_fail(3)) SWIG_fail;
12441 }
12442 {
12443 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12444 if (SWIG_arg_fail(4)) SWIG_fail;
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 (arg1)->SetMaskColour(arg2,arg3,arg4);
12449
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 Py_INCREF(Py_None); resultobj = Py_None;
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12461 PyObject *resultobj;
12462 wxImage *arg1 = (wxImage *) 0 ;
12463 unsigned char result;
12464 PyObject * obj0 = 0 ;
12465 char *kwnames[] = {
12466 (char *) "self", NULL
12467 };
12468
12469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12471 if (SWIG_arg_fail(1)) SWIG_fail;
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 result = (unsigned char)(arg1)->GetMaskRed();
12475
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 {
12480 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12481 }
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj;
12490 wxImage *arg1 = (wxImage *) 0 ;
12491 unsigned char result;
12492 PyObject * obj0 = 0 ;
12493 char *kwnames[] = {
12494 (char *) "self", NULL
12495 };
12496
12497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12499 if (SWIG_arg_fail(1)) SWIG_fail;
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = (unsigned char)(arg1)->GetMaskGreen();
12503
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 {
12508 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12509 }
12510 return resultobj;
12511 fail:
12512 return NULL;
12513 }
12514
12515
12516 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12517 PyObject *resultobj;
12518 wxImage *arg1 = (wxImage *) 0 ;
12519 unsigned char result;
12520 PyObject * obj0 = 0 ;
12521 char *kwnames[] = {
12522 (char *) "self", NULL
12523 };
12524
12525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12527 if (SWIG_arg_fail(1)) SWIG_fail;
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 result = (unsigned char)(arg1)->GetMaskBlue();
12531
12532 wxPyEndAllowThreads(__tstate);
12533 if (PyErr_Occurred()) SWIG_fail;
12534 }
12535 {
12536 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12537 }
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12545 PyObject *resultobj;
12546 wxImage *arg1 = (wxImage *) 0 ;
12547 bool arg2 = (bool) true ;
12548 PyObject * obj0 = 0 ;
12549 PyObject * obj1 = 0 ;
12550 char *kwnames[] = {
12551 (char *) "self",(char *) "mask", NULL
12552 };
12553
12554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12556 if (SWIG_arg_fail(1)) SWIG_fail;
12557 if (obj1) {
12558 {
12559 arg2 = (bool)(SWIG_As_bool(obj1));
12560 if (SWIG_arg_fail(2)) SWIG_fail;
12561 }
12562 }
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 (arg1)->SetMask(arg2);
12566
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 Py_INCREF(Py_None); resultobj = Py_None;
12571 return resultobj;
12572 fail:
12573 return NULL;
12574 }
12575
12576
12577 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12578 PyObject *resultobj;
12579 wxImage *arg1 = (wxImage *) 0 ;
12580 bool result;
12581 PyObject * obj0 = 0 ;
12582 char *kwnames[] = {
12583 (char *) "self", NULL
12584 };
12585
12586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12588 if (SWIG_arg_fail(1)) SWIG_fail;
12589 {
12590 PyThreadState* __tstate = wxPyBeginAllowThreads();
12591 result = (bool)(arg1)->HasMask();
12592
12593 wxPyEndAllowThreads(__tstate);
12594 if (PyErr_Occurred()) SWIG_fail;
12595 }
12596 {
12597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12598 }
12599 return resultobj;
12600 fail:
12601 return NULL;
12602 }
12603
12604
12605 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12606 PyObject *resultobj;
12607 wxImage *arg1 = (wxImage *) 0 ;
12608 double arg2 ;
12609 wxPoint *arg3 = 0 ;
12610 bool arg4 = (bool) true ;
12611 wxPoint *arg5 = (wxPoint *) NULL ;
12612 SwigValueWrapper<wxImage > result;
12613 wxPoint temp3 ;
12614 PyObject * obj0 = 0 ;
12615 PyObject * obj1 = 0 ;
12616 PyObject * obj2 = 0 ;
12617 PyObject * obj3 = 0 ;
12618 PyObject * obj4 = 0 ;
12619 char *kwnames[] = {
12620 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12621 };
12622
12623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12625 if (SWIG_arg_fail(1)) SWIG_fail;
12626 {
12627 arg2 = (double)(SWIG_As_double(obj1));
12628 if (SWIG_arg_fail(2)) SWIG_fail;
12629 }
12630 {
12631 arg3 = &temp3;
12632 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12633 }
12634 if (obj3) {
12635 {
12636 arg4 = (bool)(SWIG_As_bool(obj3));
12637 if (SWIG_arg_fail(4)) SWIG_fail;
12638 }
12639 }
12640 if (obj4) {
12641 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12642 if (SWIG_arg_fail(5)) SWIG_fail;
12643 }
12644 {
12645 PyThreadState* __tstate = wxPyBeginAllowThreads();
12646 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12647
12648 wxPyEndAllowThreads(__tstate);
12649 if (PyErr_Occurred()) SWIG_fail;
12650 }
12651 {
12652 wxImage * resultptr;
12653 resultptr = new wxImage((wxImage &)(result));
12654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12655 }
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12663 PyObject *resultobj;
12664 wxImage *arg1 = (wxImage *) 0 ;
12665 bool arg2 = (bool) true ;
12666 SwigValueWrapper<wxImage > result;
12667 PyObject * obj0 = 0 ;
12668 PyObject * obj1 = 0 ;
12669 char *kwnames[] = {
12670 (char *) "self",(char *) "clockwise", NULL
12671 };
12672
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12675 if (SWIG_arg_fail(1)) SWIG_fail;
12676 if (obj1) {
12677 {
12678 arg2 = (bool)(SWIG_As_bool(obj1));
12679 if (SWIG_arg_fail(2)) SWIG_fail;
12680 }
12681 }
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 result = (arg1)->Rotate90(arg2);
12685
12686 wxPyEndAllowThreads(__tstate);
12687 if (PyErr_Occurred()) SWIG_fail;
12688 }
12689 {
12690 wxImage * resultptr;
12691 resultptr = new wxImage((wxImage &)(result));
12692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12693 }
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12701 PyObject *resultobj;
12702 wxImage *arg1 = (wxImage *) 0 ;
12703 bool arg2 = (bool) true ;
12704 SwigValueWrapper<wxImage > result;
12705 PyObject * obj0 = 0 ;
12706 PyObject * obj1 = 0 ;
12707 char *kwnames[] = {
12708 (char *) "self",(char *) "horizontally", NULL
12709 };
12710
12711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12713 if (SWIG_arg_fail(1)) SWIG_fail;
12714 if (obj1) {
12715 {
12716 arg2 = (bool)(SWIG_As_bool(obj1));
12717 if (SWIG_arg_fail(2)) SWIG_fail;
12718 }
12719 }
12720 {
12721 PyThreadState* __tstate = wxPyBeginAllowThreads();
12722 result = (arg1)->Mirror(arg2);
12723
12724 wxPyEndAllowThreads(__tstate);
12725 if (PyErr_Occurred()) SWIG_fail;
12726 }
12727 {
12728 wxImage * resultptr;
12729 resultptr = new wxImage((wxImage &)(result));
12730 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12731 }
12732 return resultobj;
12733 fail:
12734 return NULL;
12735 }
12736
12737
12738 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12739 PyObject *resultobj;
12740 wxImage *arg1 = (wxImage *) 0 ;
12741 unsigned char arg2 ;
12742 unsigned char arg3 ;
12743 unsigned char arg4 ;
12744 unsigned char arg5 ;
12745 unsigned char arg6 ;
12746 unsigned char arg7 ;
12747 PyObject * obj0 = 0 ;
12748 PyObject * obj1 = 0 ;
12749 PyObject * obj2 = 0 ;
12750 PyObject * obj3 = 0 ;
12751 PyObject * obj4 = 0 ;
12752 PyObject * obj5 = 0 ;
12753 PyObject * obj6 = 0 ;
12754 char *kwnames[] = {
12755 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12756 };
12757
12758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12760 if (SWIG_arg_fail(1)) SWIG_fail;
12761 {
12762 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12763 if (SWIG_arg_fail(2)) SWIG_fail;
12764 }
12765 {
12766 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12767 if (SWIG_arg_fail(3)) SWIG_fail;
12768 }
12769 {
12770 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12771 if (SWIG_arg_fail(4)) SWIG_fail;
12772 }
12773 {
12774 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12775 if (SWIG_arg_fail(5)) SWIG_fail;
12776 }
12777 {
12778 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12779 if (SWIG_arg_fail(6)) SWIG_fail;
12780 }
12781 {
12782 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12783 if (SWIG_arg_fail(7)) SWIG_fail;
12784 }
12785 {
12786 PyThreadState* __tstate = wxPyBeginAllowThreads();
12787 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12788
12789 wxPyEndAllowThreads(__tstate);
12790 if (PyErr_Occurred()) SWIG_fail;
12791 }
12792 Py_INCREF(Py_None); resultobj = Py_None;
12793 return resultobj;
12794 fail:
12795 return NULL;
12796 }
12797
12798
12799 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12800 PyObject *resultobj;
12801 wxImage *arg1 = (wxImage *) 0 ;
12802 unsigned char arg2 ;
12803 unsigned char arg3 ;
12804 unsigned char arg4 ;
12805 SwigValueWrapper<wxImage > result;
12806 PyObject * obj0 = 0 ;
12807 PyObject * obj1 = 0 ;
12808 PyObject * obj2 = 0 ;
12809 PyObject * obj3 = 0 ;
12810 char *kwnames[] = {
12811 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12812 };
12813
12814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12816 if (SWIG_arg_fail(1)) SWIG_fail;
12817 {
12818 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12819 if (SWIG_arg_fail(2)) SWIG_fail;
12820 }
12821 {
12822 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12823 if (SWIG_arg_fail(3)) SWIG_fail;
12824 }
12825 {
12826 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12827 if (SWIG_arg_fail(4)) SWIG_fail;
12828 }
12829 {
12830 PyThreadState* __tstate = wxPyBeginAllowThreads();
12831 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12832
12833 wxPyEndAllowThreads(__tstate);
12834 if (PyErr_Occurred()) SWIG_fail;
12835 }
12836 {
12837 wxImage * resultptr;
12838 resultptr = new wxImage((wxImage &)(result));
12839 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12840 }
12841 return resultobj;
12842 fail:
12843 return NULL;
12844 }
12845
12846
12847 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12848 PyObject *resultobj;
12849 wxImage *arg1 = (wxImage *) 0 ;
12850 wxString *arg2 = 0 ;
12851 wxString *arg3 = 0 ;
12852 bool temp2 = false ;
12853 bool temp3 = false ;
12854 PyObject * obj0 = 0 ;
12855 PyObject * obj1 = 0 ;
12856 PyObject * obj2 = 0 ;
12857 char *kwnames[] = {
12858 (char *) "self",(char *) "name",(char *) "value", NULL
12859 };
12860
12861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12863 if (SWIG_arg_fail(1)) SWIG_fail;
12864 {
12865 arg2 = wxString_in_helper(obj1);
12866 if (arg2 == NULL) SWIG_fail;
12867 temp2 = true;
12868 }
12869 {
12870 arg3 = wxString_in_helper(obj2);
12871 if (arg3 == NULL) SWIG_fail;
12872 temp3 = true;
12873 }
12874 {
12875 PyThreadState* __tstate = wxPyBeginAllowThreads();
12876 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12877
12878 wxPyEndAllowThreads(__tstate);
12879 if (PyErr_Occurred()) SWIG_fail;
12880 }
12881 Py_INCREF(Py_None); resultobj = Py_None;
12882 {
12883 if (temp2)
12884 delete arg2;
12885 }
12886 {
12887 if (temp3)
12888 delete arg3;
12889 }
12890 return resultobj;
12891 fail:
12892 {
12893 if (temp2)
12894 delete arg2;
12895 }
12896 {
12897 if (temp3)
12898 delete arg3;
12899 }
12900 return NULL;
12901 }
12902
12903
12904 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12905 PyObject *resultobj;
12906 wxImage *arg1 = (wxImage *) 0 ;
12907 wxString *arg2 = 0 ;
12908 int arg3 ;
12909 bool temp2 = false ;
12910 PyObject * obj0 = 0 ;
12911 PyObject * obj1 = 0 ;
12912 PyObject * obj2 = 0 ;
12913 char *kwnames[] = {
12914 (char *) "self",(char *) "name",(char *) "value", NULL
12915 };
12916
12917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12919 if (SWIG_arg_fail(1)) SWIG_fail;
12920 {
12921 arg2 = wxString_in_helper(obj1);
12922 if (arg2 == NULL) SWIG_fail;
12923 temp2 = true;
12924 }
12925 {
12926 arg3 = (int)(SWIG_As_int(obj2));
12927 if (SWIG_arg_fail(3)) SWIG_fail;
12928 }
12929 {
12930 PyThreadState* __tstate = wxPyBeginAllowThreads();
12931 (arg1)->SetOption((wxString const &)*arg2,arg3);
12932
12933 wxPyEndAllowThreads(__tstate);
12934 if (PyErr_Occurred()) SWIG_fail;
12935 }
12936 Py_INCREF(Py_None); resultobj = Py_None;
12937 {
12938 if (temp2)
12939 delete arg2;
12940 }
12941 return resultobj;
12942 fail:
12943 {
12944 if (temp2)
12945 delete arg2;
12946 }
12947 return NULL;
12948 }
12949
12950
12951 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12952 PyObject *resultobj;
12953 wxImage *arg1 = (wxImage *) 0 ;
12954 wxString *arg2 = 0 ;
12955 wxString result;
12956 bool temp2 = false ;
12957 PyObject * obj0 = 0 ;
12958 PyObject * obj1 = 0 ;
12959 char *kwnames[] = {
12960 (char *) "self",(char *) "name", NULL
12961 };
12962
12963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12965 if (SWIG_arg_fail(1)) SWIG_fail;
12966 {
12967 arg2 = wxString_in_helper(obj1);
12968 if (arg2 == NULL) SWIG_fail;
12969 temp2 = true;
12970 }
12971 {
12972 PyThreadState* __tstate = wxPyBeginAllowThreads();
12973 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12974
12975 wxPyEndAllowThreads(__tstate);
12976 if (PyErr_Occurred()) SWIG_fail;
12977 }
12978 {
12979 #if wxUSE_UNICODE
12980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12981 #else
12982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12983 #endif
12984 }
12985 {
12986 if (temp2)
12987 delete arg2;
12988 }
12989 return resultobj;
12990 fail:
12991 {
12992 if (temp2)
12993 delete arg2;
12994 }
12995 return NULL;
12996 }
12997
12998
12999 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13000 PyObject *resultobj;
13001 wxImage *arg1 = (wxImage *) 0 ;
13002 wxString *arg2 = 0 ;
13003 int result;
13004 bool temp2 = false ;
13005 PyObject * obj0 = 0 ;
13006 PyObject * obj1 = 0 ;
13007 char *kwnames[] = {
13008 (char *) "self",(char *) "name", NULL
13009 };
13010
13011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13013 if (SWIG_arg_fail(1)) SWIG_fail;
13014 {
13015 arg2 = wxString_in_helper(obj1);
13016 if (arg2 == NULL) SWIG_fail;
13017 temp2 = true;
13018 }
13019 {
13020 PyThreadState* __tstate = wxPyBeginAllowThreads();
13021 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13022
13023 wxPyEndAllowThreads(__tstate);
13024 if (PyErr_Occurred()) SWIG_fail;
13025 }
13026 {
13027 resultobj = SWIG_From_int((int)(result));
13028 }
13029 {
13030 if (temp2)
13031 delete arg2;
13032 }
13033 return resultobj;
13034 fail:
13035 {
13036 if (temp2)
13037 delete arg2;
13038 }
13039 return NULL;
13040 }
13041
13042
13043 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13044 PyObject *resultobj;
13045 wxImage *arg1 = (wxImage *) 0 ;
13046 wxString *arg2 = 0 ;
13047 bool result;
13048 bool temp2 = false ;
13049 PyObject * obj0 = 0 ;
13050 PyObject * obj1 = 0 ;
13051 char *kwnames[] = {
13052 (char *) "self",(char *) "name", NULL
13053 };
13054
13055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13057 if (SWIG_arg_fail(1)) SWIG_fail;
13058 {
13059 arg2 = wxString_in_helper(obj1);
13060 if (arg2 == NULL) SWIG_fail;
13061 temp2 = true;
13062 }
13063 {
13064 PyThreadState* __tstate = wxPyBeginAllowThreads();
13065 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13066
13067 wxPyEndAllowThreads(__tstate);
13068 if (PyErr_Occurred()) SWIG_fail;
13069 }
13070 {
13071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13072 }
13073 {
13074 if (temp2)
13075 delete arg2;
13076 }
13077 return resultobj;
13078 fail:
13079 {
13080 if (temp2)
13081 delete arg2;
13082 }
13083 return NULL;
13084 }
13085
13086
13087 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13088 PyObject *resultobj;
13089 wxImage *arg1 = (wxImage *) 0 ;
13090 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13091 unsigned long result;
13092 PyObject * obj0 = 0 ;
13093 PyObject * obj1 = 0 ;
13094 char *kwnames[] = {
13095 (char *) "self",(char *) "stopafter", NULL
13096 };
13097
13098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13100 if (SWIG_arg_fail(1)) SWIG_fail;
13101 if (obj1) {
13102 {
13103 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13104 if (SWIG_arg_fail(2)) SWIG_fail;
13105 }
13106 }
13107 {
13108 PyThreadState* __tstate = wxPyBeginAllowThreads();
13109 result = (unsigned long)(arg1)->CountColours(arg2);
13110
13111 wxPyEndAllowThreads(__tstate);
13112 if (PyErr_Occurred()) SWIG_fail;
13113 }
13114 {
13115 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13116 }
13117 return resultobj;
13118 fail:
13119 return NULL;
13120 }
13121
13122
13123 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13124 PyObject *resultobj;
13125 wxImage *arg1 = (wxImage *) 0 ;
13126 wxImageHistogram *arg2 = 0 ;
13127 unsigned long result;
13128 PyObject * obj0 = 0 ;
13129 PyObject * obj1 = 0 ;
13130 char *kwnames[] = {
13131 (char *) "self",(char *) "h", NULL
13132 };
13133
13134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13136 if (SWIG_arg_fail(1)) SWIG_fail;
13137 {
13138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13139 if (SWIG_arg_fail(2)) SWIG_fail;
13140 if (arg2 == NULL) {
13141 SWIG_null_ref("wxImageHistogram");
13142 }
13143 if (SWIG_arg_fail(2)) SWIG_fail;
13144 }
13145 {
13146 PyThreadState* __tstate = wxPyBeginAllowThreads();
13147 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13148
13149 wxPyEndAllowThreads(__tstate);
13150 if (PyErr_Occurred()) SWIG_fail;
13151 }
13152 {
13153 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13154 }
13155 return resultobj;
13156 fail:
13157 return NULL;
13158 }
13159
13160
13161 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13162 PyObject *resultobj;
13163 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13164 PyObject * obj0 = 0 ;
13165 char *kwnames[] = {
13166 (char *) "handler", NULL
13167 };
13168
13169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13171 if (SWIG_arg_fail(1)) SWIG_fail;
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 wxImage::AddHandler(arg1);
13175
13176 wxPyEndAllowThreads(__tstate);
13177 if (PyErr_Occurred()) SWIG_fail;
13178 }
13179 Py_INCREF(Py_None); resultobj = Py_None;
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13187 PyObject *resultobj;
13188 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13189 PyObject * obj0 = 0 ;
13190 char *kwnames[] = {
13191 (char *) "handler", NULL
13192 };
13193
13194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13196 if (SWIG_arg_fail(1)) SWIG_fail;
13197 {
13198 PyThreadState* __tstate = wxPyBeginAllowThreads();
13199 wxImage::InsertHandler(arg1);
13200
13201 wxPyEndAllowThreads(__tstate);
13202 if (PyErr_Occurred()) SWIG_fail;
13203 }
13204 Py_INCREF(Py_None); resultobj = Py_None;
13205 return resultobj;
13206 fail:
13207 return NULL;
13208 }
13209
13210
13211 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13212 PyObject *resultobj;
13213 wxString *arg1 = 0 ;
13214 bool result;
13215 bool temp1 = false ;
13216 PyObject * obj0 = 0 ;
13217 char *kwnames[] = {
13218 (char *) "name", NULL
13219 };
13220
13221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13222 {
13223 arg1 = wxString_in_helper(obj0);
13224 if (arg1 == NULL) SWIG_fail;
13225 temp1 = true;
13226 }
13227 {
13228 PyThreadState* __tstate = wxPyBeginAllowThreads();
13229 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13230
13231 wxPyEndAllowThreads(__tstate);
13232 if (PyErr_Occurred()) SWIG_fail;
13233 }
13234 {
13235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13236 }
13237 {
13238 if (temp1)
13239 delete arg1;
13240 }
13241 return resultobj;
13242 fail:
13243 {
13244 if (temp1)
13245 delete arg1;
13246 }
13247 return NULL;
13248 }
13249
13250
13251 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj;
13253 wxString result;
13254 char *kwnames[] = {
13255 NULL
13256 };
13257
13258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13259 {
13260 PyThreadState* __tstate = wxPyBeginAllowThreads();
13261 result = wxImage::GetImageExtWildcard();
13262
13263 wxPyEndAllowThreads(__tstate);
13264 if (PyErr_Occurred()) SWIG_fail;
13265 }
13266 {
13267 #if wxUSE_UNICODE
13268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13269 #else
13270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13271 #endif
13272 }
13273 return resultobj;
13274 fail:
13275 return NULL;
13276 }
13277
13278
13279 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13280 PyObject *resultobj;
13281 wxImage *arg1 = (wxImage *) 0 ;
13282 int arg2 = (int) -1 ;
13283 wxBitmap result;
13284 PyObject * obj0 = 0 ;
13285 PyObject * obj1 = 0 ;
13286 char *kwnames[] = {
13287 (char *) "self",(char *) "depth", NULL
13288 };
13289
13290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13292 if (SWIG_arg_fail(1)) SWIG_fail;
13293 if (obj1) {
13294 {
13295 arg2 = (int)(SWIG_As_int(obj1));
13296 if (SWIG_arg_fail(2)) SWIG_fail;
13297 }
13298 }
13299 {
13300 if (!wxPyCheckForApp()) SWIG_fail;
13301 PyThreadState* __tstate = wxPyBeginAllowThreads();
13302 result = wxImage_ConvertToBitmap(arg1,arg2);
13303
13304 wxPyEndAllowThreads(__tstate);
13305 if (PyErr_Occurred()) SWIG_fail;
13306 }
13307 {
13308 wxBitmap * resultptr;
13309 resultptr = new wxBitmap((wxBitmap &)(result));
13310 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13311 }
13312 return resultobj;
13313 fail:
13314 return NULL;
13315 }
13316
13317
13318 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj;
13320 wxImage *arg1 = (wxImage *) 0 ;
13321 unsigned char arg2 ;
13322 unsigned char arg3 ;
13323 unsigned char arg4 ;
13324 wxBitmap result;
13325 PyObject * obj0 = 0 ;
13326 PyObject * obj1 = 0 ;
13327 PyObject * obj2 = 0 ;
13328 PyObject * obj3 = 0 ;
13329 char *kwnames[] = {
13330 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13331 };
13332
13333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13335 if (SWIG_arg_fail(1)) SWIG_fail;
13336 {
13337 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13338 if (SWIG_arg_fail(2)) SWIG_fail;
13339 }
13340 {
13341 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13342 if (SWIG_arg_fail(3)) SWIG_fail;
13343 }
13344 {
13345 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13346 if (SWIG_arg_fail(4)) SWIG_fail;
13347 }
13348 {
13349 if (!wxPyCheckForApp()) SWIG_fail;
13350 PyThreadState* __tstate = wxPyBeginAllowThreads();
13351 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13352
13353 wxPyEndAllowThreads(__tstate);
13354 if (PyErr_Occurred()) SWIG_fail;
13355 }
13356 {
13357 wxBitmap * resultptr;
13358 resultptr = new wxBitmap((wxBitmap &)(result));
13359 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13360 }
13361 return resultobj;
13362 fail:
13363 return NULL;
13364 }
13365
13366
13367 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13368 PyObject *obj;
13369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13370 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13371 Py_INCREF(obj);
13372 return Py_BuildValue((char *)"");
13373 }
13374 static int _wrap_NullImage_set(PyObject *) {
13375 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13376 return 1;
13377 }
13378
13379
13380 static PyObject *_wrap_NullImage_get(void) {
13381 PyObject *pyobj;
13382
13383 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13384 return pyobj;
13385 }
13386
13387
13388 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13389 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13390 return 1;
13391 }
13392
13393
13394 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13395 PyObject *pyobj;
13396
13397 {
13398 #if wxUSE_UNICODE
13399 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13400 #else
13401 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13402 #endif
13403 }
13404 return pyobj;
13405 }
13406
13407
13408 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13409 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13410 return 1;
13411 }
13412
13413
13414 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13415 PyObject *pyobj;
13416
13417 {
13418 #if wxUSE_UNICODE
13419 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13420 #else
13421 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13422 #endif
13423 }
13424 return pyobj;
13425 }
13426
13427
13428 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13429 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13430 return 1;
13431 }
13432
13433
13434 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13435 PyObject *pyobj;
13436
13437 {
13438 #if wxUSE_UNICODE
13439 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13440 #else
13441 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13442 #endif
13443 }
13444 return pyobj;
13445 }
13446
13447
13448 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13449 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13450 return 1;
13451 }
13452
13453
13454 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13455 PyObject *pyobj;
13456
13457 {
13458 #if wxUSE_UNICODE
13459 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13460 #else
13461 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13462 #endif
13463 }
13464 return pyobj;
13465 }
13466
13467
13468 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13469 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13470 return 1;
13471 }
13472
13473
13474 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13475 PyObject *pyobj;
13476
13477 {
13478 #if wxUSE_UNICODE
13479 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13480 #else
13481 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13482 #endif
13483 }
13484 return pyobj;
13485 }
13486
13487
13488 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13489 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13490 return 1;
13491 }
13492
13493
13494 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13495 PyObject *pyobj;
13496
13497 {
13498 #if wxUSE_UNICODE
13499 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13500 #else
13501 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13502 #endif
13503 }
13504 return pyobj;
13505 }
13506
13507
13508 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13509 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13510 return 1;
13511 }
13512
13513
13514 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13515 PyObject *pyobj;
13516
13517 {
13518 #if wxUSE_UNICODE
13519 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13520 #else
13521 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13522 #endif
13523 }
13524 return pyobj;
13525 }
13526
13527
13528 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13529 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13530 return 1;
13531 }
13532
13533
13534 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13535 PyObject *pyobj;
13536
13537 {
13538 #if wxUSE_UNICODE
13539 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13540 #else
13541 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13542 #endif
13543 }
13544 return pyobj;
13545 }
13546
13547
13548 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13549 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13550 return 1;
13551 }
13552
13553
13554 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13555 PyObject *pyobj;
13556
13557 {
13558 #if wxUSE_UNICODE
13559 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13560 #else
13561 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13562 #endif
13563 }
13564 return pyobj;
13565 }
13566
13567
13568 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13569 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13570 return 1;
13571 }
13572
13573
13574 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13575 PyObject *pyobj;
13576
13577 {
13578 #if wxUSE_UNICODE
13579 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13580 #else
13581 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13582 #endif
13583 }
13584 return pyobj;
13585 }
13586
13587
13588 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13589 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13590 return 1;
13591 }
13592
13593
13594 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13595 PyObject *pyobj;
13596
13597 {
13598 #if wxUSE_UNICODE
13599 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13600 #else
13601 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13602 #endif
13603 }
13604 return pyobj;
13605 }
13606
13607
13608 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13609 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13610 return 1;
13611 }
13612
13613
13614 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13615 PyObject *pyobj;
13616
13617 {
13618 #if wxUSE_UNICODE
13619 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13620 #else
13621 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13622 #endif
13623 }
13624 return pyobj;
13625 }
13626
13627
13628 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13629 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13630 return 1;
13631 }
13632
13633
13634 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13635 PyObject *pyobj;
13636
13637 {
13638 #if wxUSE_UNICODE
13639 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13640 #else
13641 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13642 #endif
13643 }
13644 return pyobj;
13645 }
13646
13647
13648 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
13649 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
13650 return 1;
13651 }
13652
13653
13654 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
13655 PyObject *pyobj;
13656
13657 {
13658 #if wxUSE_UNICODE
13659 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13660 #else
13661 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13662 #endif
13663 }
13664 return pyobj;
13665 }
13666
13667
13668 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
13669 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
13670 return 1;
13671 }
13672
13673
13674 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
13675 PyObject *pyobj;
13676
13677 {
13678 #if wxUSE_UNICODE
13679 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13680 #else
13681 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13682 #endif
13683 }
13684 return pyobj;
13685 }
13686
13687
13688 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13689 PyObject *resultobj;
13690 wxBMPHandler *result;
13691 char *kwnames[] = {
13692 NULL
13693 };
13694
13695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13696 {
13697 PyThreadState* __tstate = wxPyBeginAllowThreads();
13698 result = (wxBMPHandler *)new wxBMPHandler();
13699
13700 wxPyEndAllowThreads(__tstate);
13701 if (PyErr_Occurred()) SWIG_fail;
13702 }
13703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13704 return resultobj;
13705 fail:
13706 return NULL;
13707 }
13708
13709
13710 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13711 PyObject *obj;
13712 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13713 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13714 Py_INCREF(obj);
13715 return Py_BuildValue((char *)"");
13716 }
13717 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13718 PyObject *resultobj;
13719 wxICOHandler *result;
13720 char *kwnames[] = {
13721 NULL
13722 };
13723
13724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13725 {
13726 PyThreadState* __tstate = wxPyBeginAllowThreads();
13727 result = (wxICOHandler *)new wxICOHandler();
13728
13729 wxPyEndAllowThreads(__tstate);
13730 if (PyErr_Occurred()) SWIG_fail;
13731 }
13732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13733 return resultobj;
13734 fail:
13735 return NULL;
13736 }
13737
13738
13739 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13740 PyObject *obj;
13741 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13742 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13743 Py_INCREF(obj);
13744 return Py_BuildValue((char *)"");
13745 }
13746 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13747 PyObject *resultobj;
13748 wxCURHandler *result;
13749 char *kwnames[] = {
13750 NULL
13751 };
13752
13753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13754 {
13755 PyThreadState* __tstate = wxPyBeginAllowThreads();
13756 result = (wxCURHandler *)new wxCURHandler();
13757
13758 wxPyEndAllowThreads(__tstate);
13759 if (PyErr_Occurred()) SWIG_fail;
13760 }
13761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13762 return resultobj;
13763 fail:
13764 return NULL;
13765 }
13766
13767
13768 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13769 PyObject *obj;
13770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13771 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13772 Py_INCREF(obj);
13773 return Py_BuildValue((char *)"");
13774 }
13775 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13776 PyObject *resultobj;
13777 wxANIHandler *result;
13778 char *kwnames[] = {
13779 NULL
13780 };
13781
13782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13783 {
13784 PyThreadState* __tstate = wxPyBeginAllowThreads();
13785 result = (wxANIHandler *)new wxANIHandler();
13786
13787 wxPyEndAllowThreads(__tstate);
13788 if (PyErr_Occurred()) SWIG_fail;
13789 }
13790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13791 return resultobj;
13792 fail:
13793 return NULL;
13794 }
13795
13796
13797 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13798 PyObject *obj;
13799 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13800 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13801 Py_INCREF(obj);
13802 return Py_BuildValue((char *)"");
13803 }
13804 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj;
13806 wxPNGHandler *result;
13807 char *kwnames[] = {
13808 NULL
13809 };
13810
13811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13812 {
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 result = (wxPNGHandler *)new wxPNGHandler();
13815
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13827 PyObject *obj;
13828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13829 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13830 Py_INCREF(obj);
13831 return Py_BuildValue((char *)"");
13832 }
13833 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13834 PyObject *resultobj;
13835 wxGIFHandler *result;
13836 char *kwnames[] = {
13837 NULL
13838 };
13839
13840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13841 {
13842 PyThreadState* __tstate = wxPyBeginAllowThreads();
13843 result = (wxGIFHandler *)new wxGIFHandler();
13844
13845 wxPyEndAllowThreads(__tstate);
13846 if (PyErr_Occurred()) SWIG_fail;
13847 }
13848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13849 return resultobj;
13850 fail:
13851 return NULL;
13852 }
13853
13854
13855 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13856 PyObject *obj;
13857 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13858 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13859 Py_INCREF(obj);
13860 return Py_BuildValue((char *)"");
13861 }
13862 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13863 PyObject *resultobj;
13864 wxPCXHandler *result;
13865 char *kwnames[] = {
13866 NULL
13867 };
13868
13869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 result = (wxPCXHandler *)new wxPCXHandler();
13873
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13878 return resultobj;
13879 fail:
13880 return NULL;
13881 }
13882
13883
13884 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13885 PyObject *obj;
13886 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13887 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13888 Py_INCREF(obj);
13889 return Py_BuildValue((char *)"");
13890 }
13891 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13892 PyObject *resultobj;
13893 wxJPEGHandler *result;
13894 char *kwnames[] = {
13895 NULL
13896 };
13897
13898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13899 {
13900 PyThreadState* __tstate = wxPyBeginAllowThreads();
13901 result = (wxJPEGHandler *)new wxJPEGHandler();
13902
13903 wxPyEndAllowThreads(__tstate);
13904 if (PyErr_Occurred()) SWIG_fail;
13905 }
13906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13907 return resultobj;
13908 fail:
13909 return NULL;
13910 }
13911
13912
13913 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13914 PyObject *obj;
13915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13916 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13917 Py_INCREF(obj);
13918 return Py_BuildValue((char *)"");
13919 }
13920 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13921 PyObject *resultobj;
13922 wxPNMHandler *result;
13923 char *kwnames[] = {
13924 NULL
13925 };
13926
13927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13928 {
13929 PyThreadState* __tstate = wxPyBeginAllowThreads();
13930 result = (wxPNMHandler *)new wxPNMHandler();
13931
13932 wxPyEndAllowThreads(__tstate);
13933 if (PyErr_Occurred()) SWIG_fail;
13934 }
13935 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13936 return resultobj;
13937 fail:
13938 return NULL;
13939 }
13940
13941
13942 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13943 PyObject *obj;
13944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13945 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13946 Py_INCREF(obj);
13947 return Py_BuildValue((char *)"");
13948 }
13949 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13950 PyObject *resultobj;
13951 wxXPMHandler *result;
13952 char *kwnames[] = {
13953 NULL
13954 };
13955
13956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13957 {
13958 PyThreadState* __tstate = wxPyBeginAllowThreads();
13959 result = (wxXPMHandler *)new wxXPMHandler();
13960
13961 wxPyEndAllowThreads(__tstate);
13962 if (PyErr_Occurred()) SWIG_fail;
13963 }
13964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13965 return resultobj;
13966 fail:
13967 return NULL;
13968 }
13969
13970
13971 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13972 PyObject *obj;
13973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13974 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13975 Py_INCREF(obj);
13976 return Py_BuildValue((char *)"");
13977 }
13978 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13979 PyObject *resultobj;
13980 wxTIFFHandler *result;
13981 char *kwnames[] = {
13982 NULL
13983 };
13984
13985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13986 {
13987 PyThreadState* __tstate = wxPyBeginAllowThreads();
13988 result = (wxTIFFHandler *)new wxTIFFHandler();
13989
13990 wxPyEndAllowThreads(__tstate);
13991 if (PyErr_Occurred()) SWIG_fail;
13992 }
13993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13994 return resultobj;
13995 fail:
13996 return NULL;
13997 }
13998
13999
14000 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14001 PyObject *obj;
14002 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14003 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14004 Py_INCREF(obj);
14005 return Py_BuildValue((char *)"");
14006 }
14007 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14008 PyObject *resultobj;
14009 wxImage *arg1 = 0 ;
14010 wxImage *arg2 = 0 ;
14011 int arg3 = (int) 236 ;
14012 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14013 bool result;
14014 PyObject * obj0 = 0 ;
14015 PyObject * obj1 = 0 ;
14016 PyObject * obj2 = 0 ;
14017 PyObject * obj3 = 0 ;
14018 char *kwnames[] = {
14019 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14020 };
14021
14022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14023 {
14024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14025 if (SWIG_arg_fail(1)) SWIG_fail;
14026 if (arg1 == NULL) {
14027 SWIG_null_ref("wxImage");
14028 }
14029 if (SWIG_arg_fail(1)) SWIG_fail;
14030 }
14031 {
14032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14033 if (SWIG_arg_fail(2)) SWIG_fail;
14034 if (arg2 == NULL) {
14035 SWIG_null_ref("wxImage");
14036 }
14037 if (SWIG_arg_fail(2)) SWIG_fail;
14038 }
14039 if (obj2) {
14040 {
14041 arg3 = (int)(SWIG_As_int(obj2));
14042 if (SWIG_arg_fail(3)) SWIG_fail;
14043 }
14044 }
14045 if (obj3) {
14046 {
14047 arg4 = (int)(SWIG_As_int(obj3));
14048 if (SWIG_arg_fail(4)) SWIG_fail;
14049 }
14050 }
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14054
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 {
14059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14060 }
14061 return resultobj;
14062 fail:
14063 return NULL;
14064 }
14065
14066
14067 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14068 PyObject *obj;
14069 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14070 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14071 Py_INCREF(obj);
14072 return Py_BuildValue((char *)"");
14073 }
14074 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj;
14076 wxEvtHandler *result;
14077 char *kwnames[] = {
14078 NULL
14079 };
14080
14081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 result = (wxEvtHandler *)new wxEvtHandler();
14085
14086 wxPyEndAllowThreads(__tstate);
14087 if (PyErr_Occurred()) SWIG_fail;
14088 }
14089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14090 return resultobj;
14091 fail:
14092 return NULL;
14093 }
14094
14095
14096 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14097 PyObject *resultobj;
14098 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14099 wxEvtHandler *result;
14100 PyObject * obj0 = 0 ;
14101 char *kwnames[] = {
14102 (char *) "self", NULL
14103 };
14104
14105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14107 if (SWIG_arg_fail(1)) SWIG_fail;
14108 {
14109 PyThreadState* __tstate = wxPyBeginAllowThreads();
14110 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14111
14112 wxPyEndAllowThreads(__tstate);
14113 if (PyErr_Occurred()) SWIG_fail;
14114 }
14115 {
14116 resultobj = wxPyMake_wxObject(result, 0);
14117 }
14118 return resultobj;
14119 fail:
14120 return NULL;
14121 }
14122
14123
14124 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14125 PyObject *resultobj;
14126 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14127 wxEvtHandler *result;
14128 PyObject * obj0 = 0 ;
14129 char *kwnames[] = {
14130 (char *) "self", NULL
14131 };
14132
14133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14135 if (SWIG_arg_fail(1)) SWIG_fail;
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14139
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 {
14144 resultobj = wxPyMake_wxObject(result, 0);
14145 }
14146 return resultobj;
14147 fail:
14148 return NULL;
14149 }
14150
14151
14152 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14153 PyObject *resultobj;
14154 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14155 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 char *kwnames[] = {
14159 (char *) "self",(char *) "handler", NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14164 if (SWIG_arg_fail(1)) SWIG_fail;
14165 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14166 if (SWIG_arg_fail(2)) SWIG_fail;
14167 {
14168 PyThreadState* __tstate = wxPyBeginAllowThreads();
14169 (arg1)->SetNextHandler(arg2);
14170
14171 wxPyEndAllowThreads(__tstate);
14172 if (PyErr_Occurred()) SWIG_fail;
14173 }
14174 Py_INCREF(Py_None); resultobj = Py_None;
14175 return resultobj;
14176 fail:
14177 return NULL;
14178 }
14179
14180
14181 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14182 PyObject *resultobj;
14183 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14184 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14185 PyObject * obj0 = 0 ;
14186 PyObject * obj1 = 0 ;
14187 char *kwnames[] = {
14188 (char *) "self",(char *) "handler", NULL
14189 };
14190
14191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14193 if (SWIG_arg_fail(1)) SWIG_fail;
14194 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14195 if (SWIG_arg_fail(2)) SWIG_fail;
14196 {
14197 PyThreadState* __tstate = wxPyBeginAllowThreads();
14198 (arg1)->SetPreviousHandler(arg2);
14199
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 Py_INCREF(Py_None); resultobj = Py_None;
14204 return resultobj;
14205 fail:
14206 return NULL;
14207 }
14208
14209
14210 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14211 PyObject *resultobj;
14212 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14213 bool result;
14214 PyObject * obj0 = 0 ;
14215 char *kwnames[] = {
14216 (char *) "self", NULL
14217 };
14218
14219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14221 if (SWIG_arg_fail(1)) SWIG_fail;
14222 {
14223 PyThreadState* __tstate = wxPyBeginAllowThreads();
14224 result = (bool)(arg1)->GetEvtHandlerEnabled();
14225
14226 wxPyEndAllowThreads(__tstate);
14227 if (PyErr_Occurred()) SWIG_fail;
14228 }
14229 {
14230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14231 }
14232 return resultobj;
14233 fail:
14234 return NULL;
14235 }
14236
14237
14238 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14239 PyObject *resultobj;
14240 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14241 bool arg2 ;
14242 PyObject * obj0 = 0 ;
14243 PyObject * obj1 = 0 ;
14244 char *kwnames[] = {
14245 (char *) "self",(char *) "enabled", NULL
14246 };
14247
14248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14250 if (SWIG_arg_fail(1)) SWIG_fail;
14251 {
14252 arg2 = (bool)(SWIG_As_bool(obj1));
14253 if (SWIG_arg_fail(2)) SWIG_fail;
14254 }
14255 {
14256 PyThreadState* __tstate = wxPyBeginAllowThreads();
14257 (arg1)->SetEvtHandlerEnabled(arg2);
14258
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 Py_INCREF(Py_None); resultobj = Py_None;
14263 return resultobj;
14264 fail:
14265 return NULL;
14266 }
14267
14268
14269 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14270 PyObject *resultobj;
14271 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14272 wxEvent *arg2 = 0 ;
14273 bool result;
14274 PyObject * obj0 = 0 ;
14275 PyObject * obj1 = 0 ;
14276 char *kwnames[] = {
14277 (char *) "self",(char *) "event", NULL
14278 };
14279
14280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14282 if (SWIG_arg_fail(1)) SWIG_fail;
14283 {
14284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14285 if (SWIG_arg_fail(2)) SWIG_fail;
14286 if (arg2 == NULL) {
14287 SWIG_null_ref("wxEvent");
14288 }
14289 if (SWIG_arg_fail(2)) SWIG_fail;
14290 }
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (bool)(arg1)->ProcessEvent(*arg2);
14294
14295 wxPyEndAllowThreads(__tstate);
14296 if (PyErr_Occurred()) SWIG_fail;
14297 }
14298 {
14299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14300 }
14301 return resultobj;
14302 fail:
14303 return NULL;
14304 }
14305
14306
14307 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14308 PyObject *resultobj;
14309 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14310 wxEvent *arg2 = 0 ;
14311 PyObject * obj0 = 0 ;
14312 PyObject * obj1 = 0 ;
14313 char *kwnames[] = {
14314 (char *) "self",(char *) "event", NULL
14315 };
14316
14317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14319 if (SWIG_arg_fail(1)) SWIG_fail;
14320 {
14321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14322 if (SWIG_arg_fail(2)) SWIG_fail;
14323 if (arg2 == NULL) {
14324 SWIG_null_ref("wxEvent");
14325 }
14326 if (SWIG_arg_fail(2)) SWIG_fail;
14327 }
14328 {
14329 PyThreadState* __tstate = wxPyBeginAllowThreads();
14330 (arg1)->AddPendingEvent(*arg2);
14331
14332 wxPyEndAllowThreads(__tstate);
14333 if (PyErr_Occurred()) SWIG_fail;
14334 }
14335 Py_INCREF(Py_None); resultobj = Py_None;
14336 return resultobj;
14337 fail:
14338 return NULL;
14339 }
14340
14341
14342 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14343 PyObject *resultobj;
14344 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14345 PyObject * obj0 = 0 ;
14346 char *kwnames[] = {
14347 (char *) "self", NULL
14348 };
14349
14350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14352 if (SWIG_arg_fail(1)) SWIG_fail;
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 (arg1)->ProcessPendingEvents();
14356
14357 wxPyEndAllowThreads(__tstate);
14358 if (PyErr_Occurred()) SWIG_fail;
14359 }
14360 Py_INCREF(Py_None); resultobj = Py_None;
14361 return resultobj;
14362 fail:
14363 return NULL;
14364 }
14365
14366
14367 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14368 PyObject *resultobj;
14369 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14370 int arg2 ;
14371 int arg3 ;
14372 int arg4 ;
14373 PyObject *arg5 = (PyObject *) 0 ;
14374 PyObject * obj0 = 0 ;
14375 PyObject * obj1 = 0 ;
14376 PyObject * obj2 = 0 ;
14377 PyObject * obj3 = 0 ;
14378 PyObject * obj4 = 0 ;
14379 char *kwnames[] = {
14380 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14381 };
14382
14383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14385 if (SWIG_arg_fail(1)) SWIG_fail;
14386 {
14387 arg2 = (int)(SWIG_As_int(obj1));
14388 if (SWIG_arg_fail(2)) SWIG_fail;
14389 }
14390 {
14391 arg3 = (int)(SWIG_As_int(obj2));
14392 if (SWIG_arg_fail(3)) SWIG_fail;
14393 }
14394 {
14395 arg4 = (int)(SWIG_As_int(obj3));
14396 if (SWIG_arg_fail(4)) SWIG_fail;
14397 }
14398 arg5 = obj4;
14399 {
14400 PyThreadState* __tstate = wxPyBeginAllowThreads();
14401 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14402
14403 wxPyEndAllowThreads(__tstate);
14404 if (PyErr_Occurred()) SWIG_fail;
14405 }
14406 Py_INCREF(Py_None); resultobj = Py_None;
14407 return resultobj;
14408 fail:
14409 return NULL;
14410 }
14411
14412
14413 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14414 PyObject *resultobj;
14415 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14416 int arg2 ;
14417 int arg3 = (int) -1 ;
14418 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14419 bool result;
14420 PyObject * obj0 = 0 ;
14421 PyObject * obj1 = 0 ;
14422 PyObject * obj2 = 0 ;
14423 PyObject * obj3 = 0 ;
14424 char *kwnames[] = {
14425 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14426 };
14427
14428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14430 if (SWIG_arg_fail(1)) SWIG_fail;
14431 {
14432 arg2 = (int)(SWIG_As_int(obj1));
14433 if (SWIG_arg_fail(2)) SWIG_fail;
14434 }
14435 if (obj2) {
14436 {
14437 arg3 = (int)(SWIG_As_int(obj2));
14438 if (SWIG_arg_fail(3)) SWIG_fail;
14439 }
14440 }
14441 if (obj3) {
14442 {
14443 arg4 = (wxEventType)(SWIG_As_int(obj3));
14444 if (SWIG_arg_fail(4)) SWIG_fail;
14445 }
14446 }
14447 {
14448 PyThreadState* __tstate = wxPyBeginAllowThreads();
14449 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14450
14451 wxPyEndAllowThreads(__tstate);
14452 if (PyErr_Occurred()) SWIG_fail;
14453 }
14454 {
14455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14456 }
14457 return resultobj;
14458 fail:
14459 return NULL;
14460 }
14461
14462
14463 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14464 PyObject *resultobj;
14465 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14466 PyObject *arg2 = (PyObject *) 0 ;
14467 bool arg3 = (bool) true ;
14468 PyObject * obj0 = 0 ;
14469 PyObject * obj1 = 0 ;
14470 PyObject * obj2 = 0 ;
14471 char *kwnames[] = {
14472 (char *) "self",(char *) "_self",(char *) "incref", NULL
14473 };
14474
14475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14477 if (SWIG_arg_fail(1)) SWIG_fail;
14478 arg2 = obj1;
14479 if (obj2) {
14480 {
14481 arg3 = (bool)(SWIG_As_bool(obj2));
14482 if (SWIG_arg_fail(3)) SWIG_fail;
14483 }
14484 }
14485 {
14486 PyThreadState* __tstate = wxPyBeginAllowThreads();
14487 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14488
14489 wxPyEndAllowThreads(__tstate);
14490 if (PyErr_Occurred()) SWIG_fail;
14491 }
14492 Py_INCREF(Py_None); resultobj = Py_None;
14493 return resultobj;
14494 fail:
14495 return NULL;
14496 }
14497
14498
14499 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14500 PyObject *obj;
14501 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14502 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14503 Py_INCREF(obj);
14504 return Py_BuildValue((char *)"");
14505 }
14506 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14507 PyObject *resultobj;
14508 wxEventType result;
14509 char *kwnames[] = {
14510 NULL
14511 };
14512
14513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 result = (wxEventType)wxNewEventType();
14517
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 {
14522 resultobj = SWIG_From_int((int)(result));
14523 }
14524 return resultobj;
14525 fail:
14526 return NULL;
14527 }
14528
14529
14530 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14531 PyObject *resultobj;
14532 wxEvent *arg1 = (wxEvent *) 0 ;
14533 PyObject * obj0 = 0 ;
14534 char *kwnames[] = {
14535 (char *) "self", NULL
14536 };
14537
14538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14540 if (SWIG_arg_fail(1)) SWIG_fail;
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 delete arg1;
14544
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 Py_INCREF(Py_None); resultobj = Py_None;
14549 return resultobj;
14550 fail:
14551 return NULL;
14552 }
14553
14554
14555 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14556 PyObject *resultobj;
14557 wxEvent *arg1 = (wxEvent *) 0 ;
14558 wxEventType arg2 ;
14559 PyObject * obj0 = 0 ;
14560 PyObject * obj1 = 0 ;
14561 char *kwnames[] = {
14562 (char *) "self",(char *) "typ", NULL
14563 };
14564
14565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14567 if (SWIG_arg_fail(1)) SWIG_fail;
14568 {
14569 arg2 = (wxEventType)(SWIG_As_int(obj1));
14570 if (SWIG_arg_fail(2)) SWIG_fail;
14571 }
14572 {
14573 PyThreadState* __tstate = wxPyBeginAllowThreads();
14574 (arg1)->SetEventType(arg2);
14575
14576 wxPyEndAllowThreads(__tstate);
14577 if (PyErr_Occurred()) SWIG_fail;
14578 }
14579 Py_INCREF(Py_None); resultobj = Py_None;
14580 return resultobj;
14581 fail:
14582 return NULL;
14583 }
14584
14585
14586 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14587 PyObject *resultobj;
14588 wxEvent *arg1 = (wxEvent *) 0 ;
14589 wxEventType result;
14590 PyObject * obj0 = 0 ;
14591 char *kwnames[] = {
14592 (char *) "self", NULL
14593 };
14594
14595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) 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 {
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14601
14602 wxPyEndAllowThreads(__tstate);
14603 if (PyErr_Occurred()) SWIG_fail;
14604 }
14605 {
14606 resultobj = SWIG_From_int((int)(result));
14607 }
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj;
14616 wxEvent *arg1 = (wxEvent *) 0 ;
14617 wxObject *result;
14618 PyObject * obj0 = 0 ;
14619 char *kwnames[] = {
14620 (char *) "self", NULL
14621 };
14622
14623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14625 if (SWIG_arg_fail(1)) SWIG_fail;
14626 {
14627 PyThreadState* __tstate = wxPyBeginAllowThreads();
14628 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14629
14630 wxPyEndAllowThreads(__tstate);
14631 if (PyErr_Occurred()) SWIG_fail;
14632 }
14633 {
14634 resultobj = wxPyMake_wxObject(result, 0);
14635 }
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj;
14644 wxEvent *arg1 = (wxEvent *) 0 ;
14645 wxObject *arg2 = (wxObject *) 0 ;
14646 PyObject * obj0 = 0 ;
14647 PyObject * obj1 = 0 ;
14648 char *kwnames[] = {
14649 (char *) "self",(char *) "obj", NULL
14650 };
14651
14652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14654 if (SWIG_arg_fail(1)) SWIG_fail;
14655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14656 if (SWIG_arg_fail(2)) SWIG_fail;
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 (arg1)->SetEventObject(arg2);
14660
14661 wxPyEndAllowThreads(__tstate);
14662 if (PyErr_Occurred()) SWIG_fail;
14663 }
14664 Py_INCREF(Py_None); resultobj = Py_None;
14665 return resultobj;
14666 fail:
14667 return NULL;
14668 }
14669
14670
14671 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14672 PyObject *resultobj;
14673 wxEvent *arg1 = (wxEvent *) 0 ;
14674 long result;
14675 PyObject * obj0 = 0 ;
14676 char *kwnames[] = {
14677 (char *) "self", NULL
14678 };
14679
14680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14682 if (SWIG_arg_fail(1)) SWIG_fail;
14683 {
14684 PyThreadState* __tstate = wxPyBeginAllowThreads();
14685 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14686
14687 wxPyEndAllowThreads(__tstate);
14688 if (PyErr_Occurred()) SWIG_fail;
14689 }
14690 {
14691 resultobj = SWIG_From_long((long)(result));
14692 }
14693 return resultobj;
14694 fail:
14695 return NULL;
14696 }
14697
14698
14699 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14700 PyObject *resultobj;
14701 wxEvent *arg1 = (wxEvent *) 0 ;
14702 long arg2 = (long) 0 ;
14703 PyObject * obj0 = 0 ;
14704 PyObject * obj1 = 0 ;
14705 char *kwnames[] = {
14706 (char *) "self",(char *) "ts", NULL
14707 };
14708
14709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14711 if (SWIG_arg_fail(1)) SWIG_fail;
14712 if (obj1) {
14713 {
14714 arg2 = (long)(SWIG_As_long(obj1));
14715 if (SWIG_arg_fail(2)) SWIG_fail;
14716 }
14717 }
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 (arg1)->SetTimestamp(arg2);
14721
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 Py_INCREF(Py_None); resultobj = Py_None;
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14733 PyObject *resultobj;
14734 wxEvent *arg1 = (wxEvent *) 0 ;
14735 int result;
14736 PyObject * obj0 = 0 ;
14737 char *kwnames[] = {
14738 (char *) "self", NULL
14739 };
14740
14741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14743 if (SWIG_arg_fail(1)) SWIG_fail;
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 result = (int)((wxEvent const *)arg1)->GetId();
14747
14748 wxPyEndAllowThreads(__tstate);
14749 if (PyErr_Occurred()) SWIG_fail;
14750 }
14751 {
14752 resultobj = SWIG_From_int((int)(result));
14753 }
14754 return resultobj;
14755 fail:
14756 return NULL;
14757 }
14758
14759
14760 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14761 PyObject *resultobj;
14762 wxEvent *arg1 = (wxEvent *) 0 ;
14763 int arg2 ;
14764 PyObject * obj0 = 0 ;
14765 PyObject * obj1 = 0 ;
14766 char *kwnames[] = {
14767 (char *) "self",(char *) "Id", NULL
14768 };
14769
14770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14772 if (SWIG_arg_fail(1)) SWIG_fail;
14773 {
14774 arg2 = (int)(SWIG_As_int(obj1));
14775 if (SWIG_arg_fail(2)) SWIG_fail;
14776 }
14777 {
14778 PyThreadState* __tstate = wxPyBeginAllowThreads();
14779 (arg1)->SetId(arg2);
14780
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 Py_INCREF(Py_None); resultobj = Py_None;
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14792 PyObject *resultobj;
14793 wxEvent *arg1 = (wxEvent *) 0 ;
14794 bool result;
14795 PyObject * obj0 = 0 ;
14796 char *kwnames[] = {
14797 (char *) "self", NULL
14798 };
14799
14800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14802 if (SWIG_arg_fail(1)) SWIG_fail;
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14806
14807 wxPyEndAllowThreads(__tstate);
14808 if (PyErr_Occurred()) SWIG_fail;
14809 }
14810 {
14811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14812 }
14813 return resultobj;
14814 fail:
14815 return NULL;
14816 }
14817
14818
14819 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14820 PyObject *resultobj;
14821 wxEvent *arg1 = (wxEvent *) 0 ;
14822 bool arg2 = (bool) true ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 char *kwnames[] = {
14826 (char *) "self",(char *) "skip", NULL
14827 };
14828
14829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14831 if (SWIG_arg_fail(1)) SWIG_fail;
14832 if (obj1) {
14833 {
14834 arg2 = (bool)(SWIG_As_bool(obj1));
14835 if (SWIG_arg_fail(2)) SWIG_fail;
14836 }
14837 }
14838 {
14839 PyThreadState* __tstate = wxPyBeginAllowThreads();
14840 (arg1)->Skip(arg2);
14841
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 Py_INCREF(Py_None); resultobj = Py_None;
14846 return resultobj;
14847 fail:
14848 return NULL;
14849 }
14850
14851
14852 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14853 PyObject *resultobj;
14854 wxEvent *arg1 = (wxEvent *) 0 ;
14855 bool result;
14856 PyObject * obj0 = 0 ;
14857 char *kwnames[] = {
14858 (char *) "self", NULL
14859 };
14860
14861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14863 if (SWIG_arg_fail(1)) SWIG_fail;
14864 {
14865 PyThreadState* __tstate = wxPyBeginAllowThreads();
14866 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14867
14868 wxPyEndAllowThreads(__tstate);
14869 if (PyErr_Occurred()) SWIG_fail;
14870 }
14871 {
14872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14873 }
14874 return resultobj;
14875 fail:
14876 return NULL;
14877 }
14878
14879
14880 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14881 PyObject *resultobj;
14882 wxEvent *arg1 = (wxEvent *) 0 ;
14883 bool result;
14884 PyObject * obj0 = 0 ;
14885 char *kwnames[] = {
14886 (char *) "self", NULL
14887 };
14888
14889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14891 if (SWIG_arg_fail(1)) SWIG_fail;
14892 {
14893 PyThreadState* __tstate = wxPyBeginAllowThreads();
14894 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14895
14896 wxPyEndAllowThreads(__tstate);
14897 if (PyErr_Occurred()) SWIG_fail;
14898 }
14899 {
14900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14901 }
14902 return resultobj;
14903 fail:
14904 return NULL;
14905 }
14906
14907
14908 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14909 PyObject *resultobj;
14910 wxEvent *arg1 = (wxEvent *) 0 ;
14911 int result;
14912 PyObject * obj0 = 0 ;
14913 char *kwnames[] = {
14914 (char *) "self", NULL
14915 };
14916
14917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14919 if (SWIG_arg_fail(1)) SWIG_fail;
14920 {
14921 PyThreadState* __tstate = wxPyBeginAllowThreads();
14922 result = (int)(arg1)->StopPropagation();
14923
14924 wxPyEndAllowThreads(__tstate);
14925 if (PyErr_Occurred()) SWIG_fail;
14926 }
14927 {
14928 resultobj = SWIG_From_int((int)(result));
14929 }
14930 return resultobj;
14931 fail:
14932 return NULL;
14933 }
14934
14935
14936 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14937 PyObject *resultobj;
14938 wxEvent *arg1 = (wxEvent *) 0 ;
14939 int arg2 ;
14940 PyObject * obj0 = 0 ;
14941 PyObject * obj1 = 0 ;
14942 char *kwnames[] = {
14943 (char *) "self",(char *) "propagationLevel", NULL
14944 };
14945
14946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14948 if (SWIG_arg_fail(1)) SWIG_fail;
14949 {
14950 arg2 = (int)(SWIG_As_int(obj1));
14951 if (SWIG_arg_fail(2)) SWIG_fail;
14952 }
14953 {
14954 PyThreadState* __tstate = wxPyBeginAllowThreads();
14955 (arg1)->ResumePropagation(arg2);
14956
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 Py_INCREF(Py_None); resultobj = Py_None;
14961 return resultobj;
14962 fail:
14963 return NULL;
14964 }
14965
14966
14967 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14968 PyObject *resultobj;
14969 wxEvent *arg1 = (wxEvent *) 0 ;
14970 wxEvent *result;
14971 PyObject * obj0 = 0 ;
14972 char *kwnames[] = {
14973 (char *) "self", NULL
14974 };
14975
14976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14978 if (SWIG_arg_fail(1)) SWIG_fail;
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 result = (wxEvent *)(arg1)->Clone();
14982
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14994 PyObject *obj;
14995 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14996 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14997 Py_INCREF(obj);
14998 return Py_BuildValue((char *)"");
14999 }
15000 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15001 PyObject *resultobj;
15002 wxEvent *arg1 = 0 ;
15003 wxPropagationDisabler *result;
15004 PyObject * obj0 = 0 ;
15005 char *kwnames[] = {
15006 (char *) "event", NULL
15007 };
15008
15009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15010 {
15011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15012 if (SWIG_arg_fail(1)) SWIG_fail;
15013 if (arg1 == NULL) {
15014 SWIG_null_ref("wxEvent");
15015 }
15016 if (SWIG_arg_fail(1)) SWIG_fail;
15017 }
15018 {
15019 PyThreadState* __tstate = wxPyBeginAllowThreads();
15020 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15021
15022 wxPyEndAllowThreads(__tstate);
15023 if (PyErr_Occurred()) SWIG_fail;
15024 }
15025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15026 return resultobj;
15027 fail:
15028 return NULL;
15029 }
15030
15031
15032 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15033 PyObject *resultobj;
15034 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15035 PyObject * obj0 = 0 ;
15036 char *kwnames[] = {
15037 (char *) "self", NULL
15038 };
15039
15040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15042 if (SWIG_arg_fail(1)) SWIG_fail;
15043 {
15044 PyThreadState* __tstate = wxPyBeginAllowThreads();
15045 delete arg1;
15046
15047 wxPyEndAllowThreads(__tstate);
15048 if (PyErr_Occurred()) SWIG_fail;
15049 }
15050 Py_INCREF(Py_None); resultobj = Py_None;
15051 return resultobj;
15052 fail:
15053 return NULL;
15054 }
15055
15056
15057 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15058 PyObject *obj;
15059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15060 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15061 Py_INCREF(obj);
15062 return Py_BuildValue((char *)"");
15063 }
15064 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj;
15066 wxEvent *arg1 = 0 ;
15067 wxPropagateOnce *result;
15068 PyObject * obj0 = 0 ;
15069 char *kwnames[] = {
15070 (char *) "event", NULL
15071 };
15072
15073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15074 {
15075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15076 if (SWIG_arg_fail(1)) SWIG_fail;
15077 if (arg1 == NULL) {
15078 SWIG_null_ref("wxEvent");
15079 }
15080 if (SWIG_arg_fail(1)) SWIG_fail;
15081 }
15082 {
15083 PyThreadState* __tstate = wxPyBeginAllowThreads();
15084 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15085
15086 wxPyEndAllowThreads(__tstate);
15087 if (PyErr_Occurred()) SWIG_fail;
15088 }
15089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15090 return resultobj;
15091 fail:
15092 return NULL;
15093 }
15094
15095
15096 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15097 PyObject *resultobj;
15098 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15099 PyObject * obj0 = 0 ;
15100 char *kwnames[] = {
15101 (char *) "self", NULL
15102 };
15103
15104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15106 if (SWIG_arg_fail(1)) SWIG_fail;
15107 {
15108 PyThreadState* __tstate = wxPyBeginAllowThreads();
15109 delete arg1;
15110
15111 wxPyEndAllowThreads(__tstate);
15112 if (PyErr_Occurred()) SWIG_fail;
15113 }
15114 Py_INCREF(Py_None); resultobj = Py_None;
15115 return resultobj;
15116 fail:
15117 return NULL;
15118 }
15119
15120
15121 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15122 PyObject *obj;
15123 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15124 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15125 Py_INCREF(obj);
15126 return Py_BuildValue((char *)"");
15127 }
15128 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15129 PyObject *resultobj;
15130 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15131 int arg2 = (int) 0 ;
15132 wxCommandEvent *result;
15133 PyObject * obj0 = 0 ;
15134 PyObject * obj1 = 0 ;
15135 char *kwnames[] = {
15136 (char *) "commandType",(char *) "winid", NULL
15137 };
15138
15139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15140 if (obj0) {
15141 {
15142 arg1 = (wxEventType)(SWIG_As_int(obj0));
15143 if (SWIG_arg_fail(1)) SWIG_fail;
15144 }
15145 }
15146 if (obj1) {
15147 {
15148 arg2 = (int)(SWIG_As_int(obj1));
15149 if (SWIG_arg_fail(2)) SWIG_fail;
15150 }
15151 }
15152 {
15153 PyThreadState* __tstate = wxPyBeginAllowThreads();
15154 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15155
15156 wxPyEndAllowThreads(__tstate);
15157 if (PyErr_Occurred()) SWIG_fail;
15158 }
15159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15160 return resultobj;
15161 fail:
15162 return NULL;
15163 }
15164
15165
15166 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15167 PyObject *resultobj;
15168 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15169 int result;
15170 PyObject * obj0 = 0 ;
15171 char *kwnames[] = {
15172 (char *) "self", NULL
15173 };
15174
15175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15177 if (SWIG_arg_fail(1)) SWIG_fail;
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15181
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 {
15186 resultobj = SWIG_From_int((int)(result));
15187 }
15188 return resultobj;
15189 fail:
15190 return NULL;
15191 }
15192
15193
15194 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15195 PyObject *resultobj;
15196 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15197 wxString *arg2 = 0 ;
15198 bool temp2 = false ;
15199 PyObject * obj0 = 0 ;
15200 PyObject * obj1 = 0 ;
15201 char *kwnames[] = {
15202 (char *) "self",(char *) "s", NULL
15203 };
15204
15205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15207 if (SWIG_arg_fail(1)) SWIG_fail;
15208 {
15209 arg2 = wxString_in_helper(obj1);
15210 if (arg2 == NULL) SWIG_fail;
15211 temp2 = true;
15212 }
15213 {
15214 PyThreadState* __tstate = wxPyBeginAllowThreads();
15215 (arg1)->SetString((wxString const &)*arg2);
15216
15217 wxPyEndAllowThreads(__tstate);
15218 if (PyErr_Occurred()) SWIG_fail;
15219 }
15220 Py_INCREF(Py_None); resultobj = Py_None;
15221 {
15222 if (temp2)
15223 delete arg2;
15224 }
15225 return resultobj;
15226 fail:
15227 {
15228 if (temp2)
15229 delete arg2;
15230 }
15231 return NULL;
15232 }
15233
15234
15235 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15236 PyObject *resultobj;
15237 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15238 wxString result;
15239 PyObject * obj0 = 0 ;
15240 char *kwnames[] = {
15241 (char *) "self", NULL
15242 };
15243
15244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15246 if (SWIG_arg_fail(1)) SWIG_fail;
15247 {
15248 PyThreadState* __tstate = wxPyBeginAllowThreads();
15249 result = ((wxCommandEvent const *)arg1)->GetString();
15250
15251 wxPyEndAllowThreads(__tstate);
15252 if (PyErr_Occurred()) SWIG_fail;
15253 }
15254 {
15255 #if wxUSE_UNICODE
15256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15257 #else
15258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15259 #endif
15260 }
15261 return resultobj;
15262 fail:
15263 return NULL;
15264 }
15265
15266
15267 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15268 PyObject *resultobj;
15269 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15270 bool result;
15271 PyObject * obj0 = 0 ;
15272 char *kwnames[] = {
15273 (char *) "self", NULL
15274 };
15275
15276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15278 if (SWIG_arg_fail(1)) SWIG_fail;
15279 {
15280 PyThreadState* __tstate = wxPyBeginAllowThreads();
15281 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15282
15283 wxPyEndAllowThreads(__tstate);
15284 if (PyErr_Occurred()) SWIG_fail;
15285 }
15286 {
15287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15288 }
15289 return resultobj;
15290 fail:
15291 return NULL;
15292 }
15293
15294
15295 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15296 PyObject *resultobj;
15297 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15298 bool result;
15299 PyObject * obj0 = 0 ;
15300 char *kwnames[] = {
15301 (char *) "self", NULL
15302 };
15303
15304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15306 if (SWIG_arg_fail(1)) SWIG_fail;
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15310
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 {
15315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15316 }
15317 return resultobj;
15318 fail:
15319 return NULL;
15320 }
15321
15322
15323 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15324 PyObject *resultobj;
15325 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15326 long arg2 ;
15327 PyObject * obj0 = 0 ;
15328 PyObject * obj1 = 0 ;
15329 char *kwnames[] = {
15330 (char *) "self",(char *) "extraLong", NULL
15331 };
15332
15333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15335 if (SWIG_arg_fail(1)) SWIG_fail;
15336 {
15337 arg2 = (long)(SWIG_As_long(obj1));
15338 if (SWIG_arg_fail(2)) SWIG_fail;
15339 }
15340 {
15341 PyThreadState* __tstate = wxPyBeginAllowThreads();
15342 (arg1)->SetExtraLong(arg2);
15343
15344 wxPyEndAllowThreads(__tstate);
15345 if (PyErr_Occurred()) SWIG_fail;
15346 }
15347 Py_INCREF(Py_None); resultobj = Py_None;
15348 return resultobj;
15349 fail:
15350 return NULL;
15351 }
15352
15353
15354 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15355 PyObject *resultobj;
15356 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15357 long result;
15358 PyObject * obj0 = 0 ;
15359 char *kwnames[] = {
15360 (char *) "self", NULL
15361 };
15362
15363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15365 if (SWIG_arg_fail(1)) SWIG_fail;
15366 {
15367 PyThreadState* __tstate = wxPyBeginAllowThreads();
15368 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15369
15370 wxPyEndAllowThreads(__tstate);
15371 if (PyErr_Occurred()) SWIG_fail;
15372 }
15373 {
15374 resultobj = SWIG_From_long((long)(result));
15375 }
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15383 PyObject *resultobj;
15384 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15385 int arg2 ;
15386 PyObject * obj0 = 0 ;
15387 PyObject * obj1 = 0 ;
15388 char *kwnames[] = {
15389 (char *) "self",(char *) "i", NULL
15390 };
15391
15392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15394 if (SWIG_arg_fail(1)) SWIG_fail;
15395 {
15396 arg2 = (int)(SWIG_As_int(obj1));
15397 if (SWIG_arg_fail(2)) SWIG_fail;
15398 }
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 (arg1)->SetInt(arg2);
15402
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 Py_INCREF(Py_None); resultobj = Py_None;
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15416 long result;
15417 PyObject * obj0 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "self", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(1)) SWIG_fail;
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 {
15433 resultobj = SWIG_From_long((long)(result));
15434 }
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj;
15443 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15444 wxEvent *result;
15445 PyObject * obj0 = 0 ;
15446 char *kwnames[] = {
15447 (char *) "self", NULL
15448 };
15449
15450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15452 if (SWIG_arg_fail(1)) SWIG_fail;
15453 {
15454 PyThreadState* __tstate = wxPyBeginAllowThreads();
15455 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15456
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15461 return resultobj;
15462 fail:
15463 return NULL;
15464 }
15465
15466
15467 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15468 PyObject *obj;
15469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15470 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15471 Py_INCREF(obj);
15472 return Py_BuildValue((char *)"");
15473 }
15474 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15475 PyObject *resultobj;
15476 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15477 int arg2 = (int) 0 ;
15478 wxNotifyEvent *result;
15479 PyObject * obj0 = 0 ;
15480 PyObject * obj1 = 0 ;
15481 char *kwnames[] = {
15482 (char *) "commandType",(char *) "winid", NULL
15483 };
15484
15485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15486 if (obj0) {
15487 {
15488 arg1 = (wxEventType)(SWIG_As_int(obj0));
15489 if (SWIG_arg_fail(1)) SWIG_fail;
15490 }
15491 }
15492 if (obj1) {
15493 {
15494 arg2 = (int)(SWIG_As_int(obj1));
15495 if (SWIG_arg_fail(2)) SWIG_fail;
15496 }
15497 }
15498 {
15499 PyThreadState* __tstate = wxPyBeginAllowThreads();
15500 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15501
15502 wxPyEndAllowThreads(__tstate);
15503 if (PyErr_Occurred()) SWIG_fail;
15504 }
15505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15506 return resultobj;
15507 fail:
15508 return NULL;
15509 }
15510
15511
15512 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15513 PyObject *resultobj;
15514 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15515 PyObject * obj0 = 0 ;
15516 char *kwnames[] = {
15517 (char *) "self", NULL
15518 };
15519
15520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15522 if (SWIG_arg_fail(1)) SWIG_fail;
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 (arg1)->Veto();
15526
15527 wxPyEndAllowThreads(__tstate);
15528 if (PyErr_Occurred()) SWIG_fail;
15529 }
15530 Py_INCREF(Py_None); resultobj = Py_None;
15531 return resultobj;
15532 fail:
15533 return NULL;
15534 }
15535
15536
15537 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15538 PyObject *resultobj;
15539 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15540 PyObject * obj0 = 0 ;
15541 char *kwnames[] = {
15542 (char *) "self", NULL
15543 };
15544
15545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15547 if (SWIG_arg_fail(1)) SWIG_fail;
15548 {
15549 PyThreadState* __tstate = wxPyBeginAllowThreads();
15550 (arg1)->Allow();
15551
15552 wxPyEndAllowThreads(__tstate);
15553 if (PyErr_Occurred()) SWIG_fail;
15554 }
15555 Py_INCREF(Py_None); resultobj = Py_None;
15556 return resultobj;
15557 fail:
15558 return NULL;
15559 }
15560
15561
15562 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15563 PyObject *resultobj;
15564 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15565 bool result;
15566 PyObject * obj0 = 0 ;
15567 char *kwnames[] = {
15568 (char *) "self", NULL
15569 };
15570
15571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15573 if (SWIG_arg_fail(1)) SWIG_fail;
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 result = (bool)(arg1)->IsAllowed();
15577
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 {
15582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15583 }
15584 return resultobj;
15585 fail:
15586 return NULL;
15587 }
15588
15589
15590 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15591 PyObject *obj;
15592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15593 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15594 Py_INCREF(obj);
15595 return Py_BuildValue((char *)"");
15596 }
15597 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15598 PyObject *resultobj;
15599 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15600 int arg2 = (int) 0 ;
15601 int arg3 = (int) 0 ;
15602 int arg4 = (int) 0 ;
15603 wxScrollEvent *result;
15604 PyObject * obj0 = 0 ;
15605 PyObject * obj1 = 0 ;
15606 PyObject * obj2 = 0 ;
15607 PyObject * obj3 = 0 ;
15608 char *kwnames[] = {
15609 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15610 };
15611
15612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15613 if (obj0) {
15614 {
15615 arg1 = (wxEventType)(SWIG_As_int(obj0));
15616 if (SWIG_arg_fail(1)) SWIG_fail;
15617 }
15618 }
15619 if (obj1) {
15620 {
15621 arg2 = (int)(SWIG_As_int(obj1));
15622 if (SWIG_arg_fail(2)) SWIG_fail;
15623 }
15624 }
15625 if (obj2) {
15626 {
15627 arg3 = (int)(SWIG_As_int(obj2));
15628 if (SWIG_arg_fail(3)) SWIG_fail;
15629 }
15630 }
15631 if (obj3) {
15632 {
15633 arg4 = (int)(SWIG_As_int(obj3));
15634 if (SWIG_arg_fail(4)) SWIG_fail;
15635 }
15636 }
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15640
15641 wxPyEndAllowThreads(__tstate);
15642 if (PyErr_Occurred()) SWIG_fail;
15643 }
15644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15652 PyObject *resultobj;
15653 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15654 int result;
15655 PyObject * obj0 = 0 ;
15656 char *kwnames[] = {
15657 (char *) "self", NULL
15658 };
15659
15660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15662 if (SWIG_arg_fail(1)) SWIG_fail;
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15666
15667 wxPyEndAllowThreads(__tstate);
15668 if (PyErr_Occurred()) SWIG_fail;
15669 }
15670 {
15671 resultobj = SWIG_From_int((int)(result));
15672 }
15673 return resultobj;
15674 fail:
15675 return NULL;
15676 }
15677
15678
15679 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15680 PyObject *resultobj;
15681 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15682 int result;
15683 PyObject * obj0 = 0 ;
15684 char *kwnames[] = {
15685 (char *) "self", NULL
15686 };
15687
15688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15690 if (SWIG_arg_fail(1)) SWIG_fail;
15691 {
15692 PyThreadState* __tstate = wxPyBeginAllowThreads();
15693 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15694
15695 wxPyEndAllowThreads(__tstate);
15696 if (PyErr_Occurred()) SWIG_fail;
15697 }
15698 {
15699 resultobj = SWIG_From_int((int)(result));
15700 }
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15708 PyObject *resultobj;
15709 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15710 int arg2 ;
15711 PyObject * obj0 = 0 ;
15712 PyObject * obj1 = 0 ;
15713 char *kwnames[] = {
15714 (char *) "self",(char *) "orient", NULL
15715 };
15716
15717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15719 if (SWIG_arg_fail(1)) SWIG_fail;
15720 {
15721 arg2 = (int)(SWIG_As_int(obj1));
15722 if (SWIG_arg_fail(2)) SWIG_fail;
15723 }
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 (arg1)->SetOrientation(arg2);
15727
15728 wxPyEndAllowThreads(__tstate);
15729 if (PyErr_Occurred()) SWIG_fail;
15730 }
15731 Py_INCREF(Py_None); resultobj = Py_None;
15732 return resultobj;
15733 fail:
15734 return NULL;
15735 }
15736
15737
15738 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15739 PyObject *resultobj;
15740 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15741 int arg2 ;
15742 PyObject * obj0 = 0 ;
15743 PyObject * obj1 = 0 ;
15744 char *kwnames[] = {
15745 (char *) "self",(char *) "pos", NULL
15746 };
15747
15748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15750 if (SWIG_arg_fail(1)) SWIG_fail;
15751 {
15752 arg2 = (int)(SWIG_As_int(obj1));
15753 if (SWIG_arg_fail(2)) SWIG_fail;
15754 }
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 (arg1)->SetPosition(arg2);
15758
15759 wxPyEndAllowThreads(__tstate);
15760 if (PyErr_Occurred()) SWIG_fail;
15761 }
15762 Py_INCREF(Py_None); resultobj = Py_None;
15763 return resultobj;
15764 fail:
15765 return NULL;
15766 }
15767
15768
15769 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15770 PyObject *obj;
15771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15772 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15773 Py_INCREF(obj);
15774 return Py_BuildValue((char *)"");
15775 }
15776 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj;
15778 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15779 int arg2 = (int) 0 ;
15780 int arg3 = (int) 0 ;
15781 wxScrollWinEvent *result;
15782 PyObject * obj0 = 0 ;
15783 PyObject * obj1 = 0 ;
15784 PyObject * obj2 = 0 ;
15785 char *kwnames[] = {
15786 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15787 };
15788
15789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15790 if (obj0) {
15791 {
15792 arg1 = (wxEventType)(SWIG_As_int(obj0));
15793 if (SWIG_arg_fail(1)) SWIG_fail;
15794 }
15795 }
15796 if (obj1) {
15797 {
15798 arg2 = (int)(SWIG_As_int(obj1));
15799 if (SWIG_arg_fail(2)) SWIG_fail;
15800 }
15801 }
15802 if (obj2) {
15803 {
15804 arg3 = (int)(SWIG_As_int(obj2));
15805 if (SWIG_arg_fail(3)) SWIG_fail;
15806 }
15807 }
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15811
15812 wxPyEndAllowThreads(__tstate);
15813 if (PyErr_Occurred()) SWIG_fail;
15814 }
15815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15816 return resultobj;
15817 fail:
15818 return NULL;
15819 }
15820
15821
15822 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15823 PyObject *resultobj;
15824 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15825 int result;
15826 PyObject * obj0 = 0 ;
15827 char *kwnames[] = {
15828 (char *) "self", NULL
15829 };
15830
15831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15833 if (SWIG_arg_fail(1)) SWIG_fail;
15834 {
15835 PyThreadState* __tstate = wxPyBeginAllowThreads();
15836 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15837
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 {
15842 resultobj = SWIG_From_int((int)(result));
15843 }
15844 return resultobj;
15845 fail:
15846 return NULL;
15847 }
15848
15849
15850 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15851 PyObject *resultobj;
15852 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15853 int result;
15854 PyObject * obj0 = 0 ;
15855 char *kwnames[] = {
15856 (char *) "self", NULL
15857 };
15858
15859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15861 if (SWIG_arg_fail(1)) SWIG_fail;
15862 {
15863 PyThreadState* __tstate = wxPyBeginAllowThreads();
15864 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15865
15866 wxPyEndAllowThreads(__tstate);
15867 if (PyErr_Occurred()) SWIG_fail;
15868 }
15869 {
15870 resultobj = SWIG_From_int((int)(result));
15871 }
15872 return resultobj;
15873 fail:
15874 return NULL;
15875 }
15876
15877
15878 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15879 PyObject *resultobj;
15880 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15881 int arg2 ;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 char *kwnames[] = {
15885 (char *) "self",(char *) "orient", NULL
15886 };
15887
15888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 {
15892 arg2 = (int)(SWIG_As_int(obj1));
15893 if (SWIG_arg_fail(2)) SWIG_fail;
15894 }
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 (arg1)->SetOrientation(arg2);
15898
15899 wxPyEndAllowThreads(__tstate);
15900 if (PyErr_Occurred()) SWIG_fail;
15901 }
15902 Py_INCREF(Py_None); resultobj = Py_None;
15903 return resultobj;
15904 fail:
15905 return NULL;
15906 }
15907
15908
15909 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15910 PyObject *resultobj;
15911 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15912 int arg2 ;
15913 PyObject * obj0 = 0 ;
15914 PyObject * obj1 = 0 ;
15915 char *kwnames[] = {
15916 (char *) "self",(char *) "pos", NULL
15917 };
15918
15919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15921 if (SWIG_arg_fail(1)) SWIG_fail;
15922 {
15923 arg2 = (int)(SWIG_As_int(obj1));
15924 if (SWIG_arg_fail(2)) SWIG_fail;
15925 }
15926 {
15927 PyThreadState* __tstate = wxPyBeginAllowThreads();
15928 (arg1)->SetPosition(arg2);
15929
15930 wxPyEndAllowThreads(__tstate);
15931 if (PyErr_Occurred()) SWIG_fail;
15932 }
15933 Py_INCREF(Py_None); resultobj = Py_None;
15934 return resultobj;
15935 fail:
15936 return NULL;
15937 }
15938
15939
15940 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15941 PyObject *obj;
15942 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15943 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15944 Py_INCREF(obj);
15945 return Py_BuildValue((char *)"");
15946 }
15947 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15948 PyObject *resultobj;
15949 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15950 wxMouseEvent *result;
15951 PyObject * obj0 = 0 ;
15952 char *kwnames[] = {
15953 (char *) "mouseType", NULL
15954 };
15955
15956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15957 if (obj0) {
15958 {
15959 arg1 = (wxEventType)(SWIG_As_int(obj0));
15960 if (SWIG_arg_fail(1)) SWIG_fail;
15961 }
15962 }
15963 {
15964 PyThreadState* __tstate = wxPyBeginAllowThreads();
15965 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15966
15967 wxPyEndAllowThreads(__tstate);
15968 if (PyErr_Occurred()) SWIG_fail;
15969 }
15970 {
15971 resultobj = wxPyMake_wxObject(result, 1);
15972 }
15973 return resultobj;
15974 fail:
15975 return NULL;
15976 }
15977
15978
15979 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15980 PyObject *resultobj;
15981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15982 bool result;
15983 PyObject * obj0 = 0 ;
15984 char *kwnames[] = {
15985 (char *) "self", NULL
15986 };
15987
15988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15990 if (SWIG_arg_fail(1)) SWIG_fail;
15991 {
15992 PyThreadState* __tstate = wxPyBeginAllowThreads();
15993 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15994
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 {
15999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16000 }
16001 return resultobj;
16002 fail:
16003 return NULL;
16004 }
16005
16006
16007 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16008 PyObject *resultobj;
16009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16010 int arg2 = (int) wxMOUSE_BTN_ANY ;
16011 bool result;
16012 PyObject * obj0 = 0 ;
16013 PyObject * obj1 = 0 ;
16014 char *kwnames[] = {
16015 (char *) "self",(char *) "but", NULL
16016 };
16017
16018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16020 if (SWIG_arg_fail(1)) SWIG_fail;
16021 if (obj1) {
16022 {
16023 arg2 = (int)(SWIG_As_int(obj1));
16024 if (SWIG_arg_fail(2)) SWIG_fail;
16025 }
16026 }
16027 {
16028 PyThreadState* __tstate = wxPyBeginAllowThreads();
16029 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16030
16031 wxPyEndAllowThreads(__tstate);
16032 if (PyErr_Occurred()) SWIG_fail;
16033 }
16034 {
16035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16036 }
16037 return resultobj;
16038 fail:
16039 return NULL;
16040 }
16041
16042
16043 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16044 PyObject *resultobj;
16045 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16046 int arg2 = (int) wxMOUSE_BTN_ANY ;
16047 bool result;
16048 PyObject * obj0 = 0 ;
16049 PyObject * obj1 = 0 ;
16050 char *kwnames[] = {
16051 (char *) "self",(char *) "but", NULL
16052 };
16053
16054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16056 if (SWIG_arg_fail(1)) SWIG_fail;
16057 if (obj1) {
16058 {
16059 arg2 = (int)(SWIG_As_int(obj1));
16060 if (SWIG_arg_fail(2)) SWIG_fail;
16061 }
16062 }
16063 {
16064 PyThreadState* __tstate = wxPyBeginAllowThreads();
16065 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16066
16067 wxPyEndAllowThreads(__tstate);
16068 if (PyErr_Occurred()) SWIG_fail;
16069 }
16070 {
16071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16072 }
16073 return resultobj;
16074 fail:
16075 return NULL;
16076 }
16077
16078
16079 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16080 PyObject *resultobj;
16081 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16082 int arg2 = (int) wxMOUSE_BTN_ANY ;
16083 bool result;
16084 PyObject * obj0 = 0 ;
16085 PyObject * obj1 = 0 ;
16086 char *kwnames[] = {
16087 (char *) "self",(char *) "but", NULL
16088 };
16089
16090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16092 if (SWIG_arg_fail(1)) SWIG_fail;
16093 if (obj1) {
16094 {
16095 arg2 = (int)(SWIG_As_int(obj1));
16096 if (SWIG_arg_fail(2)) SWIG_fail;
16097 }
16098 }
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 {
16107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16108 }
16109 return resultobj;
16110 fail:
16111 return NULL;
16112 }
16113
16114
16115 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16116 PyObject *resultobj;
16117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16118 int arg2 ;
16119 bool result;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 char *kwnames[] = {
16123 (char *) "self",(char *) "but", NULL
16124 };
16125
16126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
16131 if (SWIG_arg_fail(2)) SWIG_fail;
16132 }
16133 {
16134 PyThreadState* __tstate = wxPyBeginAllowThreads();
16135 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16136
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 {
16141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16142 }
16143 return resultobj;
16144 fail:
16145 return NULL;
16146 }
16147
16148
16149 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16150 PyObject *resultobj;
16151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16152 int arg2 ;
16153 bool result;
16154 PyObject * obj0 = 0 ;
16155 PyObject * obj1 = 0 ;
16156 char *kwnames[] = {
16157 (char *) "self",(char *) "but", NULL
16158 };
16159
16160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16162 if (SWIG_arg_fail(1)) SWIG_fail;
16163 {
16164 arg2 = (int)(SWIG_As_int(obj1));
16165 if (SWIG_arg_fail(2)) SWIG_fail;
16166 }
16167 {
16168 PyThreadState* __tstate = wxPyBeginAllowThreads();
16169 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16170
16171 wxPyEndAllowThreads(__tstate);
16172 if (PyErr_Occurred()) SWIG_fail;
16173 }
16174 {
16175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16176 }
16177 return resultobj;
16178 fail:
16179 return NULL;
16180 }
16181
16182
16183 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16184 PyObject *resultobj;
16185 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16186 int result;
16187 PyObject * obj0 = 0 ;
16188 char *kwnames[] = {
16189 (char *) "self", NULL
16190 };
16191
16192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16194 if (SWIG_arg_fail(1)) SWIG_fail;
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16198
16199 wxPyEndAllowThreads(__tstate);
16200 if (PyErr_Occurred()) SWIG_fail;
16201 }
16202 {
16203 resultobj = SWIG_From_int((int)(result));
16204 }
16205 return resultobj;
16206 fail:
16207 return NULL;
16208 }
16209
16210
16211 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16212 PyObject *resultobj;
16213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16214 bool result;
16215 PyObject * obj0 = 0 ;
16216 char *kwnames[] = {
16217 (char *) "self", NULL
16218 };
16219
16220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16222 if (SWIG_arg_fail(1)) SWIG_fail;
16223 {
16224 PyThreadState* __tstate = wxPyBeginAllowThreads();
16225 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16226
16227 wxPyEndAllowThreads(__tstate);
16228 if (PyErr_Occurred()) SWIG_fail;
16229 }
16230 {
16231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16232 }
16233 return resultobj;
16234 fail:
16235 return NULL;
16236 }
16237
16238
16239 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16240 PyObject *resultobj;
16241 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16242 bool result;
16243 PyObject * obj0 = 0 ;
16244 char *kwnames[] = {
16245 (char *) "self", NULL
16246 };
16247
16248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16250 if (SWIG_arg_fail(1)) SWIG_fail;
16251 {
16252 PyThreadState* __tstate = wxPyBeginAllowThreads();
16253 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16254
16255 wxPyEndAllowThreads(__tstate);
16256 if (PyErr_Occurred()) SWIG_fail;
16257 }
16258 {
16259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16260 }
16261 return resultobj;
16262 fail:
16263 return NULL;
16264 }
16265
16266
16267 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16268 PyObject *resultobj;
16269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16270 bool result;
16271 PyObject * obj0 = 0 ;
16272 char *kwnames[] = {
16273 (char *) "self", NULL
16274 };
16275
16276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16278 if (SWIG_arg_fail(1)) SWIG_fail;
16279 {
16280 PyThreadState* __tstate = wxPyBeginAllowThreads();
16281 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16282
16283 wxPyEndAllowThreads(__tstate);
16284 if (PyErr_Occurred()) SWIG_fail;
16285 }
16286 {
16287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16288 }
16289 return resultobj;
16290 fail:
16291 return NULL;
16292 }
16293
16294
16295 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16296 PyObject *resultobj;
16297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16298 bool result;
16299 PyObject * obj0 = 0 ;
16300 char *kwnames[] = {
16301 (char *) "self", NULL
16302 };
16303
16304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16306 if (SWIG_arg_fail(1)) SWIG_fail;
16307 {
16308 PyThreadState* __tstate = wxPyBeginAllowThreads();
16309 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16310
16311 wxPyEndAllowThreads(__tstate);
16312 if (PyErr_Occurred()) SWIG_fail;
16313 }
16314 {
16315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16316 }
16317 return resultobj;
16318 fail:
16319 return NULL;
16320 }
16321
16322
16323 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16324 PyObject *resultobj;
16325 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16326 bool result;
16327 PyObject * obj0 = 0 ;
16328 char *kwnames[] = {
16329 (char *) "self", NULL
16330 };
16331
16332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16334 if (SWIG_arg_fail(1)) SWIG_fail;
16335 {
16336 PyThreadState* __tstate = wxPyBeginAllowThreads();
16337 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16338
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 {
16343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16344 }
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj;
16353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16354 bool result;
16355 PyObject * obj0 = 0 ;
16356 char *kwnames[] = {
16357 (char *) "self", NULL
16358 };
16359
16360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16362 if (SWIG_arg_fail(1)) SWIG_fail;
16363 {
16364 PyThreadState* __tstate = wxPyBeginAllowThreads();
16365 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16366
16367 wxPyEndAllowThreads(__tstate);
16368 if (PyErr_Occurred()) SWIG_fail;
16369 }
16370 {
16371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16372 }
16373 return resultobj;
16374 fail:
16375 return NULL;
16376 }
16377
16378
16379 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16380 PyObject *resultobj;
16381 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16382 bool result;
16383 PyObject * obj0 = 0 ;
16384 char *kwnames[] = {
16385 (char *) "self", NULL
16386 };
16387
16388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16390 if (SWIG_arg_fail(1)) SWIG_fail;
16391 {
16392 PyThreadState* __tstate = wxPyBeginAllowThreads();
16393 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16394
16395 wxPyEndAllowThreads(__tstate);
16396 if (PyErr_Occurred()) SWIG_fail;
16397 }
16398 {
16399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16400 }
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj;
16409 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16410 bool result;
16411 PyObject * obj0 = 0 ;
16412 char *kwnames[] = {
16413 (char *) "self", NULL
16414 };
16415
16416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16418 if (SWIG_arg_fail(1)) SWIG_fail;
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16422
16423 wxPyEndAllowThreads(__tstate);
16424 if (PyErr_Occurred()) SWIG_fail;
16425 }
16426 {
16427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16428 }
16429 return resultobj;
16430 fail:
16431 return NULL;
16432 }
16433
16434
16435 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16436 PyObject *resultobj;
16437 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16438 bool result;
16439 PyObject * obj0 = 0 ;
16440 char *kwnames[] = {
16441 (char *) "self", NULL
16442 };
16443
16444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16446 if (SWIG_arg_fail(1)) SWIG_fail;
16447 {
16448 PyThreadState* __tstate = wxPyBeginAllowThreads();
16449 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16450
16451 wxPyEndAllowThreads(__tstate);
16452 if (PyErr_Occurred()) SWIG_fail;
16453 }
16454 {
16455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16456 }
16457 return resultobj;
16458 fail:
16459 return NULL;
16460 }
16461
16462
16463 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16464 PyObject *resultobj;
16465 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16466 bool result;
16467 PyObject * obj0 = 0 ;
16468 char *kwnames[] = {
16469 (char *) "self", NULL
16470 };
16471
16472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16474 if (SWIG_arg_fail(1)) SWIG_fail;
16475 {
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16478
16479 wxPyEndAllowThreads(__tstate);
16480 if (PyErr_Occurred()) SWIG_fail;
16481 }
16482 {
16483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16484 }
16485 return resultobj;
16486 fail:
16487 return NULL;
16488 }
16489
16490
16491 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16492 PyObject *resultobj;
16493 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16494 bool result;
16495 PyObject * obj0 = 0 ;
16496 char *kwnames[] = {
16497 (char *) "self", NULL
16498 };
16499
16500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16502 if (SWIG_arg_fail(1)) SWIG_fail;
16503 {
16504 PyThreadState* __tstate = wxPyBeginAllowThreads();
16505 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16506
16507 wxPyEndAllowThreads(__tstate);
16508 if (PyErr_Occurred()) SWIG_fail;
16509 }
16510 {
16511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16512 }
16513 return resultobj;
16514 fail:
16515 return NULL;
16516 }
16517
16518
16519 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj;
16521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16522 bool result;
16523 PyObject * obj0 = 0 ;
16524 char *kwnames[] = {
16525 (char *) "self", NULL
16526 };
16527
16528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16530 if (SWIG_arg_fail(1)) SWIG_fail;
16531 {
16532 PyThreadState* __tstate = wxPyBeginAllowThreads();
16533 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16534
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 {
16539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16540 }
16541 return resultobj;
16542 fail:
16543 return NULL;
16544 }
16545
16546
16547 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16548 PyObject *resultobj;
16549 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16550 bool result;
16551 PyObject * obj0 = 0 ;
16552 char *kwnames[] = {
16553 (char *) "self", NULL
16554 };
16555
16556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16558 if (SWIG_arg_fail(1)) SWIG_fail;
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16562
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 {
16567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16568 }
16569 return resultobj;
16570 fail:
16571 return NULL;
16572 }
16573
16574
16575 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16576 PyObject *resultobj;
16577 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16578 bool result;
16579 PyObject * obj0 = 0 ;
16580 char *kwnames[] = {
16581 (char *) "self", NULL
16582 };
16583
16584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16586 if (SWIG_arg_fail(1)) SWIG_fail;
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16590
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 {
16595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16596 }
16597 return resultobj;
16598 fail:
16599 return NULL;
16600 }
16601
16602
16603 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16604 PyObject *resultobj;
16605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16606 bool result;
16607 PyObject * obj0 = 0 ;
16608 char *kwnames[] = {
16609 (char *) "self", NULL
16610 };
16611
16612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16614 if (SWIG_arg_fail(1)) SWIG_fail;
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 result = (bool)(arg1)->LeftIsDown();
16618
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 {
16623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16624 }
16625 return resultobj;
16626 fail:
16627 return NULL;
16628 }
16629
16630
16631 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16632 PyObject *resultobj;
16633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16634 bool result;
16635 PyObject * obj0 = 0 ;
16636 char *kwnames[] = {
16637 (char *) "self", NULL
16638 };
16639
16640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16642 if (SWIG_arg_fail(1)) SWIG_fail;
16643 {
16644 PyThreadState* __tstate = wxPyBeginAllowThreads();
16645 result = (bool)(arg1)->MiddleIsDown();
16646
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 {
16651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16652 }
16653 return resultobj;
16654 fail:
16655 return NULL;
16656 }
16657
16658
16659 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16660 PyObject *resultobj;
16661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16662 bool result;
16663 PyObject * obj0 = 0 ;
16664 char *kwnames[] = {
16665 (char *) "self", NULL
16666 };
16667
16668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16670 if (SWIG_arg_fail(1)) SWIG_fail;
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = (bool)(arg1)->RightIsDown();
16674
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 {
16679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16680 }
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16688 PyObject *resultobj;
16689 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16690 bool result;
16691 PyObject * obj0 = 0 ;
16692 char *kwnames[] = {
16693 (char *) "self", NULL
16694 };
16695
16696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16698 if (SWIG_arg_fail(1)) SWIG_fail;
16699 {
16700 PyThreadState* __tstate = wxPyBeginAllowThreads();
16701 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16702
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 {
16707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16708 }
16709 return resultobj;
16710 fail:
16711 return NULL;
16712 }
16713
16714
16715 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16716 PyObject *resultobj;
16717 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16718 bool result;
16719 PyObject * obj0 = 0 ;
16720 char *kwnames[] = {
16721 (char *) "self", NULL
16722 };
16723
16724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16726 if (SWIG_arg_fail(1)) SWIG_fail;
16727 {
16728 PyThreadState* __tstate = wxPyBeginAllowThreads();
16729 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16730
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 {
16735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16736 }
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj;
16745 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16746 bool result;
16747 PyObject * obj0 = 0 ;
16748 char *kwnames[] = {
16749 (char *) "self", NULL
16750 };
16751
16752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16754 if (SWIG_arg_fail(1)) SWIG_fail;
16755 {
16756 PyThreadState* __tstate = wxPyBeginAllowThreads();
16757 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16758
16759 wxPyEndAllowThreads(__tstate);
16760 if (PyErr_Occurred()) SWIG_fail;
16761 }
16762 {
16763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16764 }
16765 return resultobj;
16766 fail:
16767 return NULL;
16768 }
16769
16770
16771 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16772 PyObject *resultobj;
16773 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16774 bool result;
16775 PyObject * obj0 = 0 ;
16776 char *kwnames[] = {
16777 (char *) "self", NULL
16778 };
16779
16780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16782 if (SWIG_arg_fail(1)) SWIG_fail;
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16786
16787 wxPyEndAllowThreads(__tstate);
16788 if (PyErr_Occurred()) SWIG_fail;
16789 }
16790 {
16791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16792 }
16793 return resultobj;
16794 fail:
16795 return NULL;
16796 }
16797
16798
16799 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16800 PyObject *resultobj;
16801 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16802 wxPoint result;
16803 PyObject * obj0 = 0 ;
16804 char *kwnames[] = {
16805 (char *) "self", NULL
16806 };
16807
16808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16810 if (SWIG_arg_fail(1)) SWIG_fail;
16811 {
16812 PyThreadState* __tstate = wxPyBeginAllowThreads();
16813 result = (arg1)->GetPosition();
16814
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 {
16819 wxPoint * resultptr;
16820 resultptr = new wxPoint((wxPoint &)(result));
16821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16822 }
16823 return resultobj;
16824 fail:
16825 return NULL;
16826 }
16827
16828
16829 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16830 PyObject *resultobj;
16831 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16832 long *arg2 = (long *) 0 ;
16833 long *arg3 = (long *) 0 ;
16834 long temp2 ;
16835 int res2 = 0 ;
16836 long temp3 ;
16837 int res3 = 0 ;
16838 PyObject * obj0 = 0 ;
16839 char *kwnames[] = {
16840 (char *) "self", NULL
16841 };
16842
16843 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16844 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16847 if (SWIG_arg_fail(1)) SWIG_fail;
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 (arg1)->GetPosition(arg2,arg3);
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 Py_INCREF(Py_None); resultobj = Py_None;
16856 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16857 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16858 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16859 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj;
16868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16869 wxDC *arg2 = 0 ;
16870 wxPoint result;
16871 PyObject * obj0 = 0 ;
16872 PyObject * obj1 = 0 ;
16873 char *kwnames[] = {
16874 (char *) "self",(char *) "dc", NULL
16875 };
16876
16877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16879 if (SWIG_arg_fail(1)) SWIG_fail;
16880 {
16881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16882 if (SWIG_arg_fail(2)) SWIG_fail;
16883 if (arg2 == NULL) {
16884 SWIG_null_ref("wxDC");
16885 }
16886 if (SWIG_arg_fail(2)) SWIG_fail;
16887 }
16888 {
16889 PyThreadState* __tstate = wxPyBeginAllowThreads();
16890 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16891
16892 wxPyEndAllowThreads(__tstate);
16893 if (PyErr_Occurred()) SWIG_fail;
16894 }
16895 {
16896 wxPoint * resultptr;
16897 resultptr = new wxPoint((wxPoint &)(result));
16898 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16899 }
16900 return resultobj;
16901 fail:
16902 return NULL;
16903 }
16904
16905
16906 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16907 PyObject *resultobj;
16908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16909 int result;
16910 PyObject * obj0 = 0 ;
16911 char *kwnames[] = {
16912 (char *) "self", NULL
16913 };
16914
16915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16917 if (SWIG_arg_fail(1)) SWIG_fail;
16918 {
16919 PyThreadState* __tstate = wxPyBeginAllowThreads();
16920 result = (int)((wxMouseEvent const *)arg1)->GetX();
16921
16922 wxPyEndAllowThreads(__tstate);
16923 if (PyErr_Occurred()) SWIG_fail;
16924 }
16925 {
16926 resultobj = SWIG_From_int((int)(result));
16927 }
16928 return resultobj;
16929 fail:
16930 return NULL;
16931 }
16932
16933
16934 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16935 PyObject *resultobj;
16936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16937 int result;
16938 PyObject * obj0 = 0 ;
16939 char *kwnames[] = {
16940 (char *) "self", NULL
16941 };
16942
16943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16945 if (SWIG_arg_fail(1)) SWIG_fail;
16946 {
16947 PyThreadState* __tstate = wxPyBeginAllowThreads();
16948 result = (int)((wxMouseEvent const *)arg1)->GetY();
16949
16950 wxPyEndAllowThreads(__tstate);
16951 if (PyErr_Occurred()) SWIG_fail;
16952 }
16953 {
16954 resultobj = SWIG_From_int((int)(result));
16955 }
16956 return resultobj;
16957 fail:
16958 return NULL;
16959 }
16960
16961
16962 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16963 PyObject *resultobj;
16964 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16965 int result;
16966 PyObject * obj0 = 0 ;
16967 char *kwnames[] = {
16968 (char *) "self", NULL
16969 };
16970
16971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16973 if (SWIG_arg_fail(1)) SWIG_fail;
16974 {
16975 PyThreadState* __tstate = wxPyBeginAllowThreads();
16976 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16977
16978 wxPyEndAllowThreads(__tstate);
16979 if (PyErr_Occurred()) SWIG_fail;
16980 }
16981 {
16982 resultobj = SWIG_From_int((int)(result));
16983 }
16984 return resultobj;
16985 fail:
16986 return NULL;
16987 }
16988
16989
16990 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16991 PyObject *resultobj;
16992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16993 int result;
16994 PyObject * obj0 = 0 ;
16995 char *kwnames[] = {
16996 (char *) "self", NULL
16997 };
16998
16999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17001 if (SWIG_arg_fail(1)) SWIG_fail;
17002 {
17003 PyThreadState* __tstate = wxPyBeginAllowThreads();
17004 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17005
17006 wxPyEndAllowThreads(__tstate);
17007 if (PyErr_Occurred()) SWIG_fail;
17008 }
17009 {
17010 resultobj = SWIG_From_int((int)(result));
17011 }
17012 return resultobj;
17013 fail:
17014 return NULL;
17015 }
17016
17017
17018 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17019 PyObject *resultobj;
17020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17021 int result;
17022 PyObject * obj0 = 0 ;
17023 char *kwnames[] = {
17024 (char *) "self", NULL
17025 };
17026
17027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17029 if (SWIG_arg_fail(1)) SWIG_fail;
17030 {
17031 PyThreadState* __tstate = wxPyBeginAllowThreads();
17032 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17033
17034 wxPyEndAllowThreads(__tstate);
17035 if (PyErr_Occurred()) SWIG_fail;
17036 }
17037 {
17038 resultobj = SWIG_From_int((int)(result));
17039 }
17040 return resultobj;
17041 fail:
17042 return NULL;
17043 }
17044
17045
17046 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17047 PyObject *resultobj;
17048 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17049 bool result;
17050 PyObject * obj0 = 0 ;
17051 char *kwnames[] = {
17052 (char *) "self", NULL
17053 };
17054
17055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17057 if (SWIG_arg_fail(1)) SWIG_fail;
17058 {
17059 PyThreadState* __tstate = wxPyBeginAllowThreads();
17060 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17061
17062 wxPyEndAllowThreads(__tstate);
17063 if (PyErr_Occurred()) SWIG_fail;
17064 }
17065 {
17066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17067 }
17068 return resultobj;
17069 fail:
17070 return NULL;
17071 }
17072
17073
17074 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17075 PyObject *resultobj;
17076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17077 int arg2 ;
17078 PyObject * obj0 = 0 ;
17079 PyObject * obj1 = 0 ;
17080 char *kwnames[] = {
17081 (char *) "self",(char *) "m_x", NULL
17082 };
17083
17084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17086 if (SWIG_arg_fail(1)) SWIG_fail;
17087 {
17088 arg2 = (int)(SWIG_As_int(obj1));
17089 if (SWIG_arg_fail(2)) SWIG_fail;
17090 }
17091 if (arg1) (arg1)->m_x = arg2;
17092
17093 Py_INCREF(Py_None); resultobj = Py_None;
17094 return resultobj;
17095 fail:
17096 return NULL;
17097 }
17098
17099
17100 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17101 PyObject *resultobj;
17102 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17103 int result;
17104 PyObject * obj0 = 0 ;
17105 char *kwnames[] = {
17106 (char *) "self", NULL
17107 };
17108
17109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17111 if (SWIG_arg_fail(1)) SWIG_fail;
17112 result = (int) ((arg1)->m_x);
17113
17114 {
17115 resultobj = SWIG_From_int((int)(result));
17116 }
17117 return resultobj;
17118 fail:
17119 return NULL;
17120 }
17121
17122
17123 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17124 PyObject *resultobj;
17125 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17126 int arg2 ;
17127 PyObject * obj0 = 0 ;
17128 PyObject * obj1 = 0 ;
17129 char *kwnames[] = {
17130 (char *) "self",(char *) "m_y", NULL
17131 };
17132
17133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17135 if (SWIG_arg_fail(1)) SWIG_fail;
17136 {
17137 arg2 = (int)(SWIG_As_int(obj1));
17138 if (SWIG_arg_fail(2)) SWIG_fail;
17139 }
17140 if (arg1) (arg1)->m_y = arg2;
17141
17142 Py_INCREF(Py_None); resultobj = Py_None;
17143 return resultobj;
17144 fail:
17145 return NULL;
17146 }
17147
17148
17149 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17150 PyObject *resultobj;
17151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17152 int result;
17153 PyObject * obj0 = 0 ;
17154 char *kwnames[] = {
17155 (char *) "self", NULL
17156 };
17157
17158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17160 if (SWIG_arg_fail(1)) SWIG_fail;
17161 result = (int) ((arg1)->m_y);
17162
17163 {
17164 resultobj = SWIG_From_int((int)(result));
17165 }
17166 return resultobj;
17167 fail:
17168 return NULL;
17169 }
17170
17171
17172 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17173 PyObject *resultobj;
17174 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17175 bool arg2 ;
17176 PyObject * obj0 = 0 ;
17177 PyObject * obj1 = 0 ;
17178 char *kwnames[] = {
17179 (char *) "self",(char *) "m_leftDown", NULL
17180 };
17181
17182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17184 if (SWIG_arg_fail(1)) SWIG_fail;
17185 {
17186 arg2 = (bool)(SWIG_As_bool(obj1));
17187 if (SWIG_arg_fail(2)) SWIG_fail;
17188 }
17189 if (arg1) (arg1)->m_leftDown = arg2;
17190
17191 Py_INCREF(Py_None); resultobj = Py_None;
17192 return resultobj;
17193 fail:
17194 return NULL;
17195 }
17196
17197
17198 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17199 PyObject *resultobj;
17200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17201 bool result;
17202 PyObject * obj0 = 0 ;
17203 char *kwnames[] = {
17204 (char *) "self", NULL
17205 };
17206
17207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17209 if (SWIG_arg_fail(1)) SWIG_fail;
17210 result = (bool) ((arg1)->m_leftDown);
17211
17212 {
17213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17214 }
17215 return resultobj;
17216 fail:
17217 return NULL;
17218 }
17219
17220
17221 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17222 PyObject *resultobj;
17223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17224 bool arg2 ;
17225 PyObject * obj0 = 0 ;
17226 PyObject * obj1 = 0 ;
17227 char *kwnames[] = {
17228 (char *) "self",(char *) "m_middleDown", NULL
17229 };
17230
17231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17233 if (SWIG_arg_fail(1)) SWIG_fail;
17234 {
17235 arg2 = (bool)(SWIG_As_bool(obj1));
17236 if (SWIG_arg_fail(2)) SWIG_fail;
17237 }
17238 if (arg1) (arg1)->m_middleDown = arg2;
17239
17240 Py_INCREF(Py_None); resultobj = Py_None;
17241 return resultobj;
17242 fail:
17243 return NULL;
17244 }
17245
17246
17247 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17248 PyObject *resultobj;
17249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17250 bool result;
17251 PyObject * obj0 = 0 ;
17252 char *kwnames[] = {
17253 (char *) "self", NULL
17254 };
17255
17256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17258 if (SWIG_arg_fail(1)) SWIG_fail;
17259 result = (bool) ((arg1)->m_middleDown);
17260
17261 {
17262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj;
17272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17273 bool arg2 ;
17274 PyObject * obj0 = 0 ;
17275 PyObject * obj1 = 0 ;
17276 char *kwnames[] = {
17277 (char *) "self",(char *) "m_rightDown", NULL
17278 };
17279
17280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17282 if (SWIG_arg_fail(1)) SWIG_fail;
17283 {
17284 arg2 = (bool)(SWIG_As_bool(obj1));
17285 if (SWIG_arg_fail(2)) SWIG_fail;
17286 }
17287 if (arg1) (arg1)->m_rightDown = arg2;
17288
17289 Py_INCREF(Py_None); resultobj = Py_None;
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17297 PyObject *resultobj;
17298 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17299 bool result;
17300 PyObject * obj0 = 0 ;
17301 char *kwnames[] = {
17302 (char *) "self", NULL
17303 };
17304
17305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17307 if (SWIG_arg_fail(1)) SWIG_fail;
17308 result = (bool) ((arg1)->m_rightDown);
17309
17310 {
17311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17312 }
17313 return resultobj;
17314 fail:
17315 return NULL;
17316 }
17317
17318
17319 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17320 PyObject *resultobj;
17321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17322 bool arg2 ;
17323 PyObject * obj0 = 0 ;
17324 PyObject * obj1 = 0 ;
17325 char *kwnames[] = {
17326 (char *) "self",(char *) "m_controlDown", NULL
17327 };
17328
17329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17331 if (SWIG_arg_fail(1)) SWIG_fail;
17332 {
17333 arg2 = (bool)(SWIG_As_bool(obj1));
17334 if (SWIG_arg_fail(2)) SWIG_fail;
17335 }
17336 if (arg1) (arg1)->m_controlDown = arg2;
17337
17338 Py_INCREF(Py_None); resultobj = Py_None;
17339 return resultobj;
17340 fail:
17341 return NULL;
17342 }
17343
17344
17345 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17346 PyObject *resultobj;
17347 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17348 bool result;
17349 PyObject * obj0 = 0 ;
17350 char *kwnames[] = {
17351 (char *) "self", NULL
17352 };
17353
17354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17356 if (SWIG_arg_fail(1)) SWIG_fail;
17357 result = (bool) ((arg1)->m_controlDown);
17358
17359 {
17360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17361 }
17362 return resultobj;
17363 fail:
17364 return NULL;
17365 }
17366
17367
17368 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17369 PyObject *resultobj;
17370 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17371 bool arg2 ;
17372 PyObject * obj0 = 0 ;
17373 PyObject * obj1 = 0 ;
17374 char *kwnames[] = {
17375 (char *) "self",(char *) "m_shiftDown", NULL
17376 };
17377
17378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17380 if (SWIG_arg_fail(1)) SWIG_fail;
17381 {
17382 arg2 = (bool)(SWIG_As_bool(obj1));
17383 if (SWIG_arg_fail(2)) SWIG_fail;
17384 }
17385 if (arg1) (arg1)->m_shiftDown = arg2;
17386
17387 Py_INCREF(Py_None); resultobj = Py_None;
17388 return resultobj;
17389 fail:
17390 return NULL;
17391 }
17392
17393
17394 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17395 PyObject *resultobj;
17396 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17397 bool result;
17398 PyObject * obj0 = 0 ;
17399 char *kwnames[] = {
17400 (char *) "self", NULL
17401 };
17402
17403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17405 if (SWIG_arg_fail(1)) SWIG_fail;
17406 result = (bool) ((arg1)->m_shiftDown);
17407
17408 {
17409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17410 }
17411 return resultobj;
17412 fail:
17413 return NULL;
17414 }
17415
17416
17417 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17418 PyObject *resultobj;
17419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17420 bool arg2 ;
17421 PyObject * obj0 = 0 ;
17422 PyObject * obj1 = 0 ;
17423 char *kwnames[] = {
17424 (char *) "self",(char *) "m_altDown", NULL
17425 };
17426
17427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17429 if (SWIG_arg_fail(1)) SWIG_fail;
17430 {
17431 arg2 = (bool)(SWIG_As_bool(obj1));
17432 if (SWIG_arg_fail(2)) SWIG_fail;
17433 }
17434 if (arg1) (arg1)->m_altDown = arg2;
17435
17436 Py_INCREF(Py_None); resultobj = Py_None;
17437 return resultobj;
17438 fail:
17439 return NULL;
17440 }
17441
17442
17443 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17444 PyObject *resultobj;
17445 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17446 bool result;
17447 PyObject * obj0 = 0 ;
17448 char *kwnames[] = {
17449 (char *) "self", NULL
17450 };
17451
17452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17454 if (SWIG_arg_fail(1)) SWIG_fail;
17455 result = (bool) ((arg1)->m_altDown);
17456
17457 {
17458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17459 }
17460 return resultobj;
17461 fail:
17462 return NULL;
17463 }
17464
17465
17466 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17467 PyObject *resultobj;
17468 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17469 bool arg2 ;
17470 PyObject * obj0 = 0 ;
17471 PyObject * obj1 = 0 ;
17472 char *kwnames[] = {
17473 (char *) "self",(char *) "m_metaDown", NULL
17474 };
17475
17476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17478 if (SWIG_arg_fail(1)) SWIG_fail;
17479 {
17480 arg2 = (bool)(SWIG_As_bool(obj1));
17481 if (SWIG_arg_fail(2)) SWIG_fail;
17482 }
17483 if (arg1) (arg1)->m_metaDown = arg2;
17484
17485 Py_INCREF(Py_None); resultobj = Py_None;
17486 return resultobj;
17487 fail:
17488 return NULL;
17489 }
17490
17491
17492 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17493 PyObject *resultobj;
17494 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17495 bool result;
17496 PyObject * obj0 = 0 ;
17497 char *kwnames[] = {
17498 (char *) "self", NULL
17499 };
17500
17501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17503 if (SWIG_arg_fail(1)) SWIG_fail;
17504 result = (bool) ((arg1)->m_metaDown);
17505
17506 {
17507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17508 }
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17516 PyObject *resultobj;
17517 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17518 int arg2 ;
17519 PyObject * obj0 = 0 ;
17520 PyObject * obj1 = 0 ;
17521 char *kwnames[] = {
17522 (char *) "self",(char *) "m_wheelRotation", NULL
17523 };
17524
17525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17527 if (SWIG_arg_fail(1)) SWIG_fail;
17528 {
17529 arg2 = (int)(SWIG_As_int(obj1));
17530 if (SWIG_arg_fail(2)) SWIG_fail;
17531 }
17532 if (arg1) (arg1)->m_wheelRotation = arg2;
17533
17534 Py_INCREF(Py_None); resultobj = Py_None;
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj;
17543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17544 int result;
17545 PyObject * obj0 = 0 ;
17546 char *kwnames[] = {
17547 (char *) "self", NULL
17548 };
17549
17550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17552 if (SWIG_arg_fail(1)) SWIG_fail;
17553 result = (int) ((arg1)->m_wheelRotation);
17554
17555 {
17556 resultobj = SWIG_From_int((int)(result));
17557 }
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj;
17566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17567 int arg2 ;
17568 PyObject * obj0 = 0 ;
17569 PyObject * obj1 = 0 ;
17570 char *kwnames[] = {
17571 (char *) "self",(char *) "m_wheelDelta", NULL
17572 };
17573
17574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17576 if (SWIG_arg_fail(1)) SWIG_fail;
17577 {
17578 arg2 = (int)(SWIG_As_int(obj1));
17579 if (SWIG_arg_fail(2)) SWIG_fail;
17580 }
17581 if (arg1) (arg1)->m_wheelDelta = arg2;
17582
17583 Py_INCREF(Py_None); resultobj = Py_None;
17584 return resultobj;
17585 fail:
17586 return NULL;
17587 }
17588
17589
17590 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17591 PyObject *resultobj;
17592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17593 int result;
17594 PyObject * obj0 = 0 ;
17595 char *kwnames[] = {
17596 (char *) "self", NULL
17597 };
17598
17599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17601 if (SWIG_arg_fail(1)) SWIG_fail;
17602 result = (int) ((arg1)->m_wheelDelta);
17603
17604 {
17605 resultobj = SWIG_From_int((int)(result));
17606 }
17607 return resultobj;
17608 fail:
17609 return NULL;
17610 }
17611
17612
17613 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17614 PyObject *resultobj;
17615 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17616 int arg2 ;
17617 PyObject * obj0 = 0 ;
17618 PyObject * obj1 = 0 ;
17619 char *kwnames[] = {
17620 (char *) "self",(char *) "m_linesPerAction", NULL
17621 };
17622
17623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17625 if (SWIG_arg_fail(1)) SWIG_fail;
17626 {
17627 arg2 = (int)(SWIG_As_int(obj1));
17628 if (SWIG_arg_fail(2)) SWIG_fail;
17629 }
17630 if (arg1) (arg1)->m_linesPerAction = arg2;
17631
17632 Py_INCREF(Py_None); resultobj = Py_None;
17633 return resultobj;
17634 fail:
17635 return NULL;
17636 }
17637
17638
17639 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj;
17641 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17642 int result;
17643 PyObject * obj0 = 0 ;
17644 char *kwnames[] = {
17645 (char *) "self", NULL
17646 };
17647
17648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17650 if (SWIG_arg_fail(1)) SWIG_fail;
17651 result = (int) ((arg1)->m_linesPerAction);
17652
17653 {
17654 resultobj = SWIG_From_int((int)(result));
17655 }
17656 return resultobj;
17657 fail:
17658 return NULL;
17659 }
17660
17661
17662 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17663 PyObject *obj;
17664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17665 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17666 Py_INCREF(obj);
17667 return Py_BuildValue((char *)"");
17668 }
17669 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17670 PyObject *resultobj;
17671 int arg1 = (int) 0 ;
17672 int arg2 = (int) 0 ;
17673 wxSetCursorEvent *result;
17674 PyObject * obj0 = 0 ;
17675 PyObject * obj1 = 0 ;
17676 char *kwnames[] = {
17677 (char *) "x",(char *) "y", NULL
17678 };
17679
17680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17681 if (obj0) {
17682 {
17683 arg1 = (int)(SWIG_As_int(obj0));
17684 if (SWIG_arg_fail(1)) SWIG_fail;
17685 }
17686 }
17687 if (obj1) {
17688 {
17689 arg2 = (int)(SWIG_As_int(obj1));
17690 if (SWIG_arg_fail(2)) SWIG_fail;
17691 }
17692 }
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17696
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17701 return resultobj;
17702 fail:
17703 return NULL;
17704 }
17705
17706
17707 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17708 PyObject *resultobj;
17709 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17710 int result;
17711 PyObject * obj0 = 0 ;
17712 char *kwnames[] = {
17713 (char *) "self", NULL
17714 };
17715
17716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17718 if (SWIG_arg_fail(1)) SWIG_fail;
17719 {
17720 PyThreadState* __tstate = wxPyBeginAllowThreads();
17721 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17722
17723 wxPyEndAllowThreads(__tstate);
17724 if (PyErr_Occurred()) SWIG_fail;
17725 }
17726 {
17727 resultobj = SWIG_From_int((int)(result));
17728 }
17729 return resultobj;
17730 fail:
17731 return NULL;
17732 }
17733
17734
17735 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17736 PyObject *resultobj;
17737 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17738 int result;
17739 PyObject * obj0 = 0 ;
17740 char *kwnames[] = {
17741 (char *) "self", NULL
17742 };
17743
17744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17746 if (SWIG_arg_fail(1)) SWIG_fail;
17747 {
17748 PyThreadState* __tstate = wxPyBeginAllowThreads();
17749 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17750
17751 wxPyEndAllowThreads(__tstate);
17752 if (PyErr_Occurred()) SWIG_fail;
17753 }
17754 {
17755 resultobj = SWIG_From_int((int)(result));
17756 }
17757 return resultobj;
17758 fail:
17759 return NULL;
17760 }
17761
17762
17763 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj;
17765 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17766 wxCursor *arg2 = 0 ;
17767 PyObject * obj0 = 0 ;
17768 PyObject * obj1 = 0 ;
17769 char *kwnames[] = {
17770 (char *) "self",(char *) "cursor", NULL
17771 };
17772
17773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17775 if (SWIG_arg_fail(1)) SWIG_fail;
17776 {
17777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17778 if (SWIG_arg_fail(2)) SWIG_fail;
17779 if (arg2 == NULL) {
17780 SWIG_null_ref("wxCursor");
17781 }
17782 if (SWIG_arg_fail(2)) SWIG_fail;
17783 }
17784 {
17785 PyThreadState* __tstate = wxPyBeginAllowThreads();
17786 (arg1)->SetCursor((wxCursor const &)*arg2);
17787
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 Py_INCREF(Py_None); resultobj = Py_None;
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17799 PyObject *resultobj;
17800 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17801 wxCursor *result;
17802 PyObject * obj0 = 0 ;
17803 char *kwnames[] = {
17804 (char *) "self", NULL
17805 };
17806
17807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17809 if (SWIG_arg_fail(1)) SWIG_fail;
17810 {
17811 PyThreadState* __tstate = wxPyBeginAllowThreads();
17812 {
17813 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17814 result = (wxCursor *) &_result_ref;
17815 }
17816
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 wxCursor* resultptr = new wxCursor(*result);
17822 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17823 }
17824 return resultobj;
17825 fail:
17826 return NULL;
17827 }
17828
17829
17830 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17831 PyObject *resultobj;
17832 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17833 bool result;
17834 PyObject * obj0 = 0 ;
17835 char *kwnames[] = {
17836 (char *) "self", NULL
17837 };
17838
17839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17841 if (SWIG_arg_fail(1)) SWIG_fail;
17842 {
17843 PyThreadState* __tstate = wxPyBeginAllowThreads();
17844 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17845
17846 wxPyEndAllowThreads(__tstate);
17847 if (PyErr_Occurred()) SWIG_fail;
17848 }
17849 {
17850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17851 }
17852 return resultobj;
17853 fail:
17854 return NULL;
17855 }
17856
17857
17858 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17859 PyObject *obj;
17860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17861 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17862 Py_INCREF(obj);
17863 return Py_BuildValue((char *)"");
17864 }
17865 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17866 PyObject *resultobj;
17867 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17868 wxKeyEvent *result;
17869 PyObject * obj0 = 0 ;
17870 char *kwnames[] = {
17871 (char *) "keyType", NULL
17872 };
17873
17874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17875 if (obj0) {
17876 {
17877 arg1 = (wxEventType)(SWIG_As_int(obj0));
17878 if (SWIG_arg_fail(1)) SWIG_fail;
17879 }
17880 }
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17884
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17889 return resultobj;
17890 fail:
17891 return NULL;
17892 }
17893
17894
17895 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17896 PyObject *resultobj;
17897 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17898 bool result;
17899 PyObject * obj0 = 0 ;
17900 char *kwnames[] = {
17901 (char *) "self", NULL
17902 };
17903
17904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17906 if (SWIG_arg_fail(1)) SWIG_fail;
17907 {
17908 PyThreadState* __tstate = wxPyBeginAllowThreads();
17909 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17910
17911 wxPyEndAllowThreads(__tstate);
17912 if (PyErr_Occurred()) SWIG_fail;
17913 }
17914 {
17915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17916 }
17917 return resultobj;
17918 fail:
17919 return NULL;
17920 }
17921
17922
17923 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17924 PyObject *resultobj;
17925 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17926 bool result;
17927 PyObject * obj0 = 0 ;
17928 char *kwnames[] = {
17929 (char *) "self", NULL
17930 };
17931
17932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17934 if (SWIG_arg_fail(1)) SWIG_fail;
17935 {
17936 PyThreadState* __tstate = wxPyBeginAllowThreads();
17937 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17938
17939 wxPyEndAllowThreads(__tstate);
17940 if (PyErr_Occurred()) SWIG_fail;
17941 }
17942 {
17943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17944 }
17945 return resultobj;
17946 fail:
17947 return NULL;
17948 }
17949
17950
17951 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17952 PyObject *resultobj;
17953 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17954 bool result;
17955 PyObject * obj0 = 0 ;
17956 char *kwnames[] = {
17957 (char *) "self", NULL
17958 };
17959
17960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17962 if (SWIG_arg_fail(1)) SWIG_fail;
17963 {
17964 PyThreadState* __tstate = wxPyBeginAllowThreads();
17965 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17966
17967 wxPyEndAllowThreads(__tstate);
17968 if (PyErr_Occurred()) SWIG_fail;
17969 }
17970 {
17971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17972 }
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17980 PyObject *resultobj;
17981 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17982 bool result;
17983 PyObject * obj0 = 0 ;
17984 char *kwnames[] = {
17985 (char *) "self", NULL
17986 };
17987
17988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17990 if (SWIG_arg_fail(1)) SWIG_fail;
17991 {
17992 PyThreadState* __tstate = wxPyBeginAllowThreads();
17993 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17994
17995 wxPyEndAllowThreads(__tstate);
17996 if (PyErr_Occurred()) SWIG_fail;
17997 }
17998 {
17999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18000 }
18001 return resultobj;
18002 fail:
18003 return NULL;
18004 }
18005
18006
18007 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18008 PyObject *resultobj;
18009 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18010 bool result;
18011 PyObject * obj0 = 0 ;
18012 char *kwnames[] = {
18013 (char *) "self", NULL
18014 };
18015
18016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18018 if (SWIG_arg_fail(1)) SWIG_fail;
18019 {
18020 PyThreadState* __tstate = wxPyBeginAllowThreads();
18021 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18022
18023 wxPyEndAllowThreads(__tstate);
18024 if (PyErr_Occurred()) SWIG_fail;
18025 }
18026 {
18027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18028 }
18029 return resultobj;
18030 fail:
18031 return NULL;
18032 }
18033
18034
18035 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18036 PyObject *resultobj;
18037 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18038 bool result;
18039 PyObject * obj0 = 0 ;
18040 char *kwnames[] = {
18041 (char *) "self", NULL
18042 };
18043
18044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18046 if (SWIG_arg_fail(1)) SWIG_fail;
18047 {
18048 PyThreadState* __tstate = wxPyBeginAllowThreads();
18049 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18050
18051 wxPyEndAllowThreads(__tstate);
18052 if (PyErr_Occurred()) SWIG_fail;
18053 }
18054 {
18055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18056 }
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18064 PyObject *resultobj;
18065 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18066 int result;
18067 PyObject * obj0 = 0 ;
18068 char *kwnames[] = {
18069 (char *) "self", NULL
18070 };
18071
18072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18074 if (SWIG_arg_fail(1)) SWIG_fail;
18075 {
18076 PyThreadState* __tstate = wxPyBeginAllowThreads();
18077 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18078
18079 wxPyEndAllowThreads(__tstate);
18080 if (PyErr_Occurred()) SWIG_fail;
18081 }
18082 {
18083 resultobj = SWIG_From_int((int)(result));
18084 }
18085 return resultobj;
18086 fail:
18087 return NULL;
18088 }
18089
18090
18091 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18092 PyObject *resultobj;
18093 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18094 int result;
18095 PyObject * obj0 = 0 ;
18096 char *kwnames[] = {
18097 (char *) "self", NULL
18098 };
18099
18100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18102 if (SWIG_arg_fail(1)) SWIG_fail;
18103 {
18104 PyThreadState* __tstate = wxPyBeginAllowThreads();
18105 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18106
18107 wxPyEndAllowThreads(__tstate);
18108 if (PyErr_Occurred()) SWIG_fail;
18109 }
18110 {
18111 resultobj = SWIG_From_int((int)(result));
18112 }
18113 return resultobj;
18114 fail:
18115 return NULL;
18116 }
18117
18118
18119 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18120 PyObject *resultobj;
18121 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18122 unsigned int result;
18123 PyObject * obj0 = 0 ;
18124 char *kwnames[] = {
18125 (char *) "self", NULL
18126 };
18127
18128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18130 if (SWIG_arg_fail(1)) SWIG_fail;
18131 {
18132 PyThreadState* __tstate = wxPyBeginAllowThreads();
18133 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18134
18135 wxPyEndAllowThreads(__tstate);
18136 if (PyErr_Occurred()) SWIG_fail;
18137 }
18138 {
18139 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18140 }
18141 return resultobj;
18142 fail:
18143 return NULL;
18144 }
18145
18146
18147 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18148 PyObject *resultobj;
18149 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18150 unsigned int result;
18151 PyObject * obj0 = 0 ;
18152 char *kwnames[] = {
18153 (char *) "self", NULL
18154 };
18155
18156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18158 if (SWIG_arg_fail(1)) SWIG_fail;
18159 {
18160 PyThreadState* __tstate = wxPyBeginAllowThreads();
18161 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18162
18163 wxPyEndAllowThreads(__tstate);
18164 if (PyErr_Occurred()) SWIG_fail;
18165 }
18166 {
18167 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18168 }
18169 return resultobj;
18170 fail:
18171 return NULL;
18172 }
18173
18174
18175 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18176 PyObject *resultobj;
18177 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18178 wxPoint result;
18179 PyObject * obj0 = 0 ;
18180 char *kwnames[] = {
18181 (char *) "self", NULL
18182 };
18183
18184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18186 if (SWIG_arg_fail(1)) SWIG_fail;
18187 {
18188 PyThreadState* __tstate = wxPyBeginAllowThreads();
18189 result = (arg1)->GetPosition();
18190
18191 wxPyEndAllowThreads(__tstate);
18192 if (PyErr_Occurred()) SWIG_fail;
18193 }
18194 {
18195 wxPoint * resultptr;
18196 resultptr = new wxPoint((wxPoint &)(result));
18197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18198 }
18199 return resultobj;
18200 fail:
18201 return NULL;
18202 }
18203
18204
18205 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18206 PyObject *resultobj;
18207 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18208 long *arg2 = (long *) 0 ;
18209 long *arg3 = (long *) 0 ;
18210 long temp2 ;
18211 int res2 = 0 ;
18212 long temp3 ;
18213 int res3 = 0 ;
18214 PyObject * obj0 = 0 ;
18215 char *kwnames[] = {
18216 (char *) "self", NULL
18217 };
18218
18219 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18220 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
18226 (arg1)->GetPosition(arg2,arg3);
18227
18228 wxPyEndAllowThreads(__tstate);
18229 if (PyErr_Occurred()) SWIG_fail;
18230 }
18231 Py_INCREF(Py_None); resultobj = Py_None;
18232 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18233 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18234 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18235 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18236 return resultobj;
18237 fail:
18238 return NULL;
18239 }
18240
18241
18242 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18243 PyObject *resultobj;
18244 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18245 int result;
18246 PyObject * obj0 = 0 ;
18247 char *kwnames[] = {
18248 (char *) "self", NULL
18249 };
18250
18251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18253 if (SWIG_arg_fail(1)) SWIG_fail;
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 result = (int)((wxKeyEvent const *)arg1)->GetX();
18257
18258 wxPyEndAllowThreads(__tstate);
18259 if (PyErr_Occurred()) SWIG_fail;
18260 }
18261 {
18262 resultobj = SWIG_From_int((int)(result));
18263 }
18264 return resultobj;
18265 fail:
18266 return NULL;
18267 }
18268
18269
18270 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18271 PyObject *resultobj;
18272 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18273 int result;
18274 PyObject * obj0 = 0 ;
18275 char *kwnames[] = {
18276 (char *) "self", NULL
18277 };
18278
18279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18281 if (SWIG_arg_fail(1)) SWIG_fail;
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (int)((wxKeyEvent const *)arg1)->GetY();
18285
18286 wxPyEndAllowThreads(__tstate);
18287 if (PyErr_Occurred()) SWIG_fail;
18288 }
18289 {
18290 resultobj = SWIG_From_int((int)(result));
18291 }
18292 return resultobj;
18293 fail:
18294 return NULL;
18295 }
18296
18297
18298 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18299 PyObject *resultobj;
18300 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18301 int arg2 ;
18302 PyObject * obj0 = 0 ;
18303 PyObject * obj1 = 0 ;
18304 char *kwnames[] = {
18305 (char *) "self",(char *) "m_x", NULL
18306 };
18307
18308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18310 if (SWIG_arg_fail(1)) SWIG_fail;
18311 {
18312 arg2 = (int)(SWIG_As_int(obj1));
18313 if (SWIG_arg_fail(2)) SWIG_fail;
18314 }
18315 if (arg1) (arg1)->m_x = arg2;
18316
18317 Py_INCREF(Py_None); resultobj = Py_None;
18318 return resultobj;
18319 fail:
18320 return NULL;
18321 }
18322
18323
18324 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18325 PyObject *resultobj;
18326 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18327 int result;
18328 PyObject * obj0 = 0 ;
18329 char *kwnames[] = {
18330 (char *) "self", NULL
18331 };
18332
18333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18335 if (SWIG_arg_fail(1)) SWIG_fail;
18336 result = (int) ((arg1)->m_x);
18337
18338 {
18339 resultobj = SWIG_From_int((int)(result));
18340 }
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18348 PyObject *resultobj;
18349 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18350 int arg2 ;
18351 PyObject * obj0 = 0 ;
18352 PyObject * obj1 = 0 ;
18353 char *kwnames[] = {
18354 (char *) "self",(char *) "m_y", NULL
18355 };
18356
18357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18359 if (SWIG_arg_fail(1)) SWIG_fail;
18360 {
18361 arg2 = (int)(SWIG_As_int(obj1));
18362 if (SWIG_arg_fail(2)) SWIG_fail;
18363 }
18364 if (arg1) (arg1)->m_y = arg2;
18365
18366 Py_INCREF(Py_None); resultobj = Py_None;
18367 return resultobj;
18368 fail:
18369 return NULL;
18370 }
18371
18372
18373 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18374 PyObject *resultobj;
18375 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18376 int result;
18377 PyObject * obj0 = 0 ;
18378 char *kwnames[] = {
18379 (char *) "self", NULL
18380 };
18381
18382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18384 if (SWIG_arg_fail(1)) SWIG_fail;
18385 result = (int) ((arg1)->m_y);
18386
18387 {
18388 resultobj = SWIG_From_int((int)(result));
18389 }
18390 return resultobj;
18391 fail:
18392 return NULL;
18393 }
18394
18395
18396 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18397 PyObject *resultobj;
18398 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18399 long arg2 ;
18400 PyObject * obj0 = 0 ;
18401 PyObject * obj1 = 0 ;
18402 char *kwnames[] = {
18403 (char *) "self",(char *) "m_keyCode", NULL
18404 };
18405
18406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18408 if (SWIG_arg_fail(1)) SWIG_fail;
18409 {
18410 arg2 = (long)(SWIG_As_long(obj1));
18411 if (SWIG_arg_fail(2)) SWIG_fail;
18412 }
18413 if (arg1) (arg1)->m_keyCode = arg2;
18414
18415 Py_INCREF(Py_None); resultobj = Py_None;
18416 return resultobj;
18417 fail:
18418 return NULL;
18419 }
18420
18421
18422 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18423 PyObject *resultobj;
18424 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18425 long result;
18426 PyObject * obj0 = 0 ;
18427 char *kwnames[] = {
18428 (char *) "self", NULL
18429 };
18430
18431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18433 if (SWIG_arg_fail(1)) SWIG_fail;
18434 result = (long) ((arg1)->m_keyCode);
18435
18436 {
18437 resultobj = SWIG_From_long((long)(result));
18438 }
18439 return resultobj;
18440 fail:
18441 return NULL;
18442 }
18443
18444
18445 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18446 PyObject *resultobj;
18447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18448 bool arg2 ;
18449 PyObject * obj0 = 0 ;
18450 PyObject * obj1 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "self",(char *) "m_controlDown", NULL
18453 };
18454
18455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18457 if (SWIG_arg_fail(1)) SWIG_fail;
18458 {
18459 arg2 = (bool)(SWIG_As_bool(obj1));
18460 if (SWIG_arg_fail(2)) SWIG_fail;
18461 }
18462 if (arg1) (arg1)->m_controlDown = arg2;
18463
18464 Py_INCREF(Py_None); resultobj = Py_None;
18465 return resultobj;
18466 fail:
18467 return NULL;
18468 }
18469
18470
18471 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18472 PyObject *resultobj;
18473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18474 bool result;
18475 PyObject * obj0 = 0 ;
18476 char *kwnames[] = {
18477 (char *) "self", NULL
18478 };
18479
18480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18482 if (SWIG_arg_fail(1)) SWIG_fail;
18483 result = (bool) ((arg1)->m_controlDown);
18484
18485 {
18486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18487 }
18488 return resultobj;
18489 fail:
18490 return NULL;
18491 }
18492
18493
18494 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18495 PyObject *resultobj;
18496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18497 bool arg2 ;
18498 PyObject * obj0 = 0 ;
18499 PyObject * obj1 = 0 ;
18500 char *kwnames[] = {
18501 (char *) "self",(char *) "m_shiftDown", NULL
18502 };
18503
18504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18506 if (SWIG_arg_fail(1)) SWIG_fail;
18507 {
18508 arg2 = (bool)(SWIG_As_bool(obj1));
18509 if (SWIG_arg_fail(2)) SWIG_fail;
18510 }
18511 if (arg1) (arg1)->m_shiftDown = arg2;
18512
18513 Py_INCREF(Py_None); resultobj = Py_None;
18514 return resultobj;
18515 fail:
18516 return NULL;
18517 }
18518
18519
18520 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18521 PyObject *resultobj;
18522 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18523 bool result;
18524 PyObject * obj0 = 0 ;
18525 char *kwnames[] = {
18526 (char *) "self", NULL
18527 };
18528
18529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18531 if (SWIG_arg_fail(1)) SWIG_fail;
18532 result = (bool) ((arg1)->m_shiftDown);
18533
18534 {
18535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18536 }
18537 return resultobj;
18538 fail:
18539 return NULL;
18540 }
18541
18542
18543 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18544 PyObject *resultobj;
18545 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18546 bool arg2 ;
18547 PyObject * obj0 = 0 ;
18548 PyObject * obj1 = 0 ;
18549 char *kwnames[] = {
18550 (char *) "self",(char *) "m_altDown", NULL
18551 };
18552
18553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18555 if (SWIG_arg_fail(1)) SWIG_fail;
18556 {
18557 arg2 = (bool)(SWIG_As_bool(obj1));
18558 if (SWIG_arg_fail(2)) SWIG_fail;
18559 }
18560 if (arg1) (arg1)->m_altDown = arg2;
18561
18562 Py_INCREF(Py_None); resultobj = Py_None;
18563 return resultobj;
18564 fail:
18565 return NULL;
18566 }
18567
18568
18569 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18570 PyObject *resultobj;
18571 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18572 bool result;
18573 PyObject * obj0 = 0 ;
18574 char *kwnames[] = {
18575 (char *) "self", NULL
18576 };
18577
18578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18580 if (SWIG_arg_fail(1)) SWIG_fail;
18581 result = (bool) ((arg1)->m_altDown);
18582
18583 {
18584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18585 }
18586 return resultobj;
18587 fail:
18588 return NULL;
18589 }
18590
18591
18592 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18593 PyObject *resultobj;
18594 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18595 bool arg2 ;
18596 PyObject * obj0 = 0 ;
18597 PyObject * obj1 = 0 ;
18598 char *kwnames[] = {
18599 (char *) "self",(char *) "m_metaDown", NULL
18600 };
18601
18602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18604 if (SWIG_arg_fail(1)) SWIG_fail;
18605 {
18606 arg2 = (bool)(SWIG_As_bool(obj1));
18607 if (SWIG_arg_fail(2)) SWIG_fail;
18608 }
18609 if (arg1) (arg1)->m_metaDown = arg2;
18610
18611 Py_INCREF(Py_None); resultobj = Py_None;
18612 return resultobj;
18613 fail:
18614 return NULL;
18615 }
18616
18617
18618 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18619 PyObject *resultobj;
18620 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18621 bool result;
18622 PyObject * obj0 = 0 ;
18623 char *kwnames[] = {
18624 (char *) "self", NULL
18625 };
18626
18627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18629 if (SWIG_arg_fail(1)) SWIG_fail;
18630 result = (bool) ((arg1)->m_metaDown);
18631
18632 {
18633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18634 }
18635 return resultobj;
18636 fail:
18637 return NULL;
18638 }
18639
18640
18641 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18642 PyObject *resultobj;
18643 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18644 bool arg2 ;
18645 PyObject * obj0 = 0 ;
18646 PyObject * obj1 = 0 ;
18647 char *kwnames[] = {
18648 (char *) "self",(char *) "m_scanCode", NULL
18649 };
18650
18651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18653 if (SWIG_arg_fail(1)) SWIG_fail;
18654 {
18655 arg2 = (bool)(SWIG_As_bool(obj1));
18656 if (SWIG_arg_fail(2)) SWIG_fail;
18657 }
18658 if (arg1) (arg1)->m_scanCode = arg2;
18659
18660 Py_INCREF(Py_None); resultobj = Py_None;
18661 return resultobj;
18662 fail:
18663 return NULL;
18664 }
18665
18666
18667 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18668 PyObject *resultobj;
18669 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18670 bool result;
18671 PyObject * obj0 = 0 ;
18672 char *kwnames[] = {
18673 (char *) "self", NULL
18674 };
18675
18676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18678 if (SWIG_arg_fail(1)) SWIG_fail;
18679 result = (bool) ((arg1)->m_scanCode);
18680
18681 {
18682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18683 }
18684 return resultobj;
18685 fail:
18686 return NULL;
18687 }
18688
18689
18690 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18691 PyObject *resultobj;
18692 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18693 unsigned int arg2 ;
18694 PyObject * obj0 = 0 ;
18695 PyObject * obj1 = 0 ;
18696 char *kwnames[] = {
18697 (char *) "self",(char *) "m_rawCode", NULL
18698 };
18699
18700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18702 if (SWIG_arg_fail(1)) SWIG_fail;
18703 {
18704 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18705 if (SWIG_arg_fail(2)) SWIG_fail;
18706 }
18707 if (arg1) (arg1)->m_rawCode = arg2;
18708
18709 Py_INCREF(Py_None); resultobj = Py_None;
18710 return resultobj;
18711 fail:
18712 return NULL;
18713 }
18714
18715
18716 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18717 PyObject *resultobj;
18718 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18719 unsigned int result;
18720 PyObject * obj0 = 0 ;
18721 char *kwnames[] = {
18722 (char *) "self", NULL
18723 };
18724
18725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18727 if (SWIG_arg_fail(1)) SWIG_fail;
18728 result = (unsigned int) ((arg1)->m_rawCode);
18729
18730 {
18731 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18732 }
18733 return resultobj;
18734 fail:
18735 return NULL;
18736 }
18737
18738
18739 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18740 PyObject *resultobj;
18741 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18742 unsigned int arg2 ;
18743 PyObject * obj0 = 0 ;
18744 PyObject * obj1 = 0 ;
18745 char *kwnames[] = {
18746 (char *) "self",(char *) "m_rawFlags", NULL
18747 };
18748
18749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18751 if (SWIG_arg_fail(1)) SWIG_fail;
18752 {
18753 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18754 if (SWIG_arg_fail(2)) SWIG_fail;
18755 }
18756 if (arg1) (arg1)->m_rawFlags = arg2;
18757
18758 Py_INCREF(Py_None); resultobj = Py_None;
18759 return resultobj;
18760 fail:
18761 return NULL;
18762 }
18763
18764
18765 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18766 PyObject *resultobj;
18767 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18768 unsigned int result;
18769 PyObject * obj0 = 0 ;
18770 char *kwnames[] = {
18771 (char *) "self", NULL
18772 };
18773
18774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18776 if (SWIG_arg_fail(1)) SWIG_fail;
18777 result = (unsigned int) ((arg1)->m_rawFlags);
18778
18779 {
18780 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18781 }
18782 return resultobj;
18783 fail:
18784 return NULL;
18785 }
18786
18787
18788 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18789 PyObject *obj;
18790 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18791 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18792 Py_INCREF(obj);
18793 return Py_BuildValue((char *)"");
18794 }
18795 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18796 PyObject *resultobj;
18797 wxSize const &arg1_defvalue = wxDefaultSize ;
18798 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18799 int arg2 = (int) 0 ;
18800 wxSizeEvent *result;
18801 wxSize temp1 ;
18802 PyObject * obj0 = 0 ;
18803 PyObject * obj1 = 0 ;
18804 char *kwnames[] = {
18805 (char *) "sz",(char *) "winid", NULL
18806 };
18807
18808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18809 if (obj0) {
18810 {
18811 arg1 = &temp1;
18812 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18813 }
18814 }
18815 if (obj1) {
18816 {
18817 arg2 = (int)(SWIG_As_int(obj1));
18818 if (SWIG_arg_fail(2)) SWIG_fail;
18819 }
18820 }
18821 {
18822 PyThreadState* __tstate = wxPyBeginAllowThreads();
18823 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18824
18825 wxPyEndAllowThreads(__tstate);
18826 if (PyErr_Occurred()) SWIG_fail;
18827 }
18828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18829 return resultobj;
18830 fail:
18831 return NULL;
18832 }
18833
18834
18835 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18836 PyObject *resultobj;
18837 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18838 wxSize result;
18839 PyObject * obj0 = 0 ;
18840 char *kwnames[] = {
18841 (char *) "self", NULL
18842 };
18843
18844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18846 if (SWIG_arg_fail(1)) SWIG_fail;
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 result = ((wxSizeEvent const *)arg1)->GetSize();
18850
18851 wxPyEndAllowThreads(__tstate);
18852 if (PyErr_Occurred()) SWIG_fail;
18853 }
18854 {
18855 wxSize * resultptr;
18856 resultptr = new wxSize((wxSize &)(result));
18857 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18858 }
18859 return resultobj;
18860 fail:
18861 return NULL;
18862 }
18863
18864
18865 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18866 PyObject *resultobj;
18867 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18868 wxRect result;
18869 PyObject * obj0 = 0 ;
18870 char *kwnames[] = {
18871 (char *) "self", NULL
18872 };
18873
18874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18876 if (SWIG_arg_fail(1)) SWIG_fail;
18877 {
18878 PyThreadState* __tstate = wxPyBeginAllowThreads();
18879 result = ((wxSizeEvent const *)arg1)->GetRect();
18880
18881 wxPyEndAllowThreads(__tstate);
18882 if (PyErr_Occurred()) SWIG_fail;
18883 }
18884 {
18885 wxRect * resultptr;
18886 resultptr = new wxRect((wxRect &)(result));
18887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18888 }
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18896 PyObject *resultobj;
18897 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18898 wxRect arg2 ;
18899 PyObject * obj0 = 0 ;
18900 PyObject * obj1 = 0 ;
18901 char *kwnames[] = {
18902 (char *) "self",(char *) "rect", NULL
18903 };
18904
18905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 {
18909 wxRect * argp;
18910 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18911 if (SWIG_arg_fail(2)) SWIG_fail;
18912 if (argp == NULL) {
18913 SWIG_null_ref("wxRect");
18914 }
18915 if (SWIG_arg_fail(2)) SWIG_fail;
18916 arg2 = *argp;
18917 }
18918 {
18919 PyThreadState* __tstate = wxPyBeginAllowThreads();
18920 (arg1)->SetRect(arg2);
18921
18922 wxPyEndAllowThreads(__tstate);
18923 if (PyErr_Occurred()) SWIG_fail;
18924 }
18925 Py_INCREF(Py_None); resultobj = Py_None;
18926 return resultobj;
18927 fail:
18928 return NULL;
18929 }
18930
18931
18932 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18933 PyObject *resultobj;
18934 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18935 wxSize arg2 ;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 char *kwnames[] = {
18939 (char *) "self",(char *) "size", NULL
18940 };
18941
18942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18944 if (SWIG_arg_fail(1)) SWIG_fail;
18945 {
18946 wxSize * argp;
18947 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18948 if (SWIG_arg_fail(2)) SWIG_fail;
18949 if (argp == NULL) {
18950 SWIG_null_ref("wxSize");
18951 }
18952 if (SWIG_arg_fail(2)) SWIG_fail;
18953 arg2 = *argp;
18954 }
18955 {
18956 PyThreadState* __tstate = wxPyBeginAllowThreads();
18957 wxSizeEvent_SetSize(arg1,arg2);
18958
18959 wxPyEndAllowThreads(__tstate);
18960 if (PyErr_Occurred()) SWIG_fail;
18961 }
18962 Py_INCREF(Py_None); resultobj = Py_None;
18963 return resultobj;
18964 fail:
18965 return NULL;
18966 }
18967
18968
18969 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18970 PyObject *resultobj;
18971 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18972 wxSize *arg2 = (wxSize *) 0 ;
18973 PyObject * obj0 = 0 ;
18974 PyObject * obj1 = 0 ;
18975 char *kwnames[] = {
18976 (char *) "self",(char *) "m_size", NULL
18977 };
18978
18979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18981 if (SWIG_arg_fail(1)) SWIG_fail;
18982 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18983 if (SWIG_arg_fail(2)) SWIG_fail;
18984 if (arg1) (arg1)->m_size = *arg2;
18985
18986 Py_INCREF(Py_None); resultobj = Py_None;
18987 return resultobj;
18988 fail:
18989 return NULL;
18990 }
18991
18992
18993 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18994 PyObject *resultobj;
18995 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18996 wxSize *result;
18997 PyObject * obj0 = 0 ;
18998 char *kwnames[] = {
18999 (char *) "self", NULL
19000 };
19001
19002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19004 if (SWIG_arg_fail(1)) SWIG_fail;
19005 result = (wxSize *)& ((arg1)->m_size);
19006
19007 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19008 return resultobj;
19009 fail:
19010 return NULL;
19011 }
19012
19013
19014 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19015 PyObject *resultobj;
19016 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19017 wxRect *arg2 = (wxRect *) 0 ;
19018 PyObject * obj0 = 0 ;
19019 PyObject * obj1 = 0 ;
19020 char *kwnames[] = {
19021 (char *) "self",(char *) "m_rect", NULL
19022 };
19023
19024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19026 if (SWIG_arg_fail(1)) SWIG_fail;
19027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19028 if (SWIG_arg_fail(2)) SWIG_fail;
19029 if (arg1) (arg1)->m_rect = *arg2;
19030
19031 Py_INCREF(Py_None); resultobj = Py_None;
19032 return resultobj;
19033 fail:
19034 return NULL;
19035 }
19036
19037
19038 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19039 PyObject *resultobj;
19040 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19041 wxRect *result;
19042 PyObject * obj0 = 0 ;
19043 char *kwnames[] = {
19044 (char *) "self", NULL
19045 };
19046
19047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19049 if (SWIG_arg_fail(1)) SWIG_fail;
19050 result = (wxRect *)& ((arg1)->m_rect);
19051
19052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19060 PyObject *obj;
19061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19062 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19063 Py_INCREF(obj);
19064 return Py_BuildValue((char *)"");
19065 }
19066 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19067 PyObject *resultobj;
19068 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19069 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19070 int arg2 = (int) 0 ;
19071 wxMoveEvent *result;
19072 wxPoint temp1 ;
19073 PyObject * obj0 = 0 ;
19074 PyObject * obj1 = 0 ;
19075 char *kwnames[] = {
19076 (char *) "pos",(char *) "winid", NULL
19077 };
19078
19079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19080 if (obj0) {
19081 {
19082 arg1 = &temp1;
19083 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19084 }
19085 }
19086 if (obj1) {
19087 {
19088 arg2 = (int)(SWIG_As_int(obj1));
19089 if (SWIG_arg_fail(2)) SWIG_fail;
19090 }
19091 }
19092 {
19093 PyThreadState* __tstate = wxPyBeginAllowThreads();
19094 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19095
19096 wxPyEndAllowThreads(__tstate);
19097 if (PyErr_Occurred()) SWIG_fail;
19098 }
19099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19100 return resultobj;
19101 fail:
19102 return NULL;
19103 }
19104
19105
19106 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj;
19108 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19109 wxPoint result;
19110 PyObject * obj0 = 0 ;
19111 char *kwnames[] = {
19112 (char *) "self", NULL
19113 };
19114
19115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19117 if (SWIG_arg_fail(1)) SWIG_fail;
19118 {
19119 PyThreadState* __tstate = wxPyBeginAllowThreads();
19120 result = ((wxMoveEvent const *)arg1)->GetPosition();
19121
19122 wxPyEndAllowThreads(__tstate);
19123 if (PyErr_Occurred()) SWIG_fail;
19124 }
19125 {
19126 wxPoint * resultptr;
19127 resultptr = new wxPoint((wxPoint &)(result));
19128 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19129 }
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19137 PyObject *resultobj;
19138 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19139 wxRect result;
19140 PyObject * obj0 = 0 ;
19141 char *kwnames[] = {
19142 (char *) "self", NULL
19143 };
19144
19145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19147 if (SWIG_arg_fail(1)) SWIG_fail;
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 result = ((wxMoveEvent const *)arg1)->GetRect();
19151
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 {
19156 wxRect * resultptr;
19157 resultptr = new wxRect((wxRect &)(result));
19158 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19159 }
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19167 PyObject *resultobj;
19168 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19169 wxRect *arg2 = 0 ;
19170 wxRect temp2 ;
19171 PyObject * obj0 = 0 ;
19172 PyObject * obj1 = 0 ;
19173 char *kwnames[] = {
19174 (char *) "self",(char *) "rect", NULL
19175 };
19176
19177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19179 if (SWIG_arg_fail(1)) SWIG_fail;
19180 {
19181 arg2 = &temp2;
19182 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19183 }
19184 {
19185 PyThreadState* __tstate = wxPyBeginAllowThreads();
19186 (arg1)->SetRect((wxRect const &)*arg2);
19187
19188 wxPyEndAllowThreads(__tstate);
19189 if (PyErr_Occurred()) SWIG_fail;
19190 }
19191 Py_INCREF(Py_None); resultobj = Py_None;
19192 return resultobj;
19193 fail:
19194 return NULL;
19195 }
19196
19197
19198 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19199 PyObject *resultobj;
19200 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19201 wxPoint *arg2 = 0 ;
19202 wxPoint temp2 ;
19203 PyObject * obj0 = 0 ;
19204 PyObject * obj1 = 0 ;
19205 char *kwnames[] = {
19206 (char *) "self",(char *) "pos", NULL
19207 };
19208
19209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19211 if (SWIG_arg_fail(1)) SWIG_fail;
19212 {
19213 arg2 = &temp2;
19214 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19215 }
19216 {
19217 PyThreadState* __tstate = wxPyBeginAllowThreads();
19218 (arg1)->SetPosition((wxPoint const &)*arg2);
19219
19220 wxPyEndAllowThreads(__tstate);
19221 if (PyErr_Occurred()) SWIG_fail;
19222 }
19223 Py_INCREF(Py_None); resultobj = Py_None;
19224 return resultobj;
19225 fail:
19226 return NULL;
19227 }
19228
19229
19230 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19231 PyObject *obj;
19232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19233 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19234 Py_INCREF(obj);
19235 return Py_BuildValue((char *)"");
19236 }
19237 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19238 PyObject *resultobj;
19239 int arg1 = (int) 0 ;
19240 wxPaintEvent *result;
19241 PyObject * obj0 = 0 ;
19242 char *kwnames[] = {
19243 (char *) "Id", NULL
19244 };
19245
19246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19247 if (obj0) {
19248 {
19249 arg1 = (int)(SWIG_As_int(obj0));
19250 if (SWIG_arg_fail(1)) SWIG_fail;
19251 }
19252 }
19253 {
19254 PyThreadState* __tstate = wxPyBeginAllowThreads();
19255 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19256
19257 wxPyEndAllowThreads(__tstate);
19258 if (PyErr_Occurred()) SWIG_fail;
19259 }
19260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19261 return resultobj;
19262 fail:
19263 return NULL;
19264 }
19265
19266
19267 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19268 PyObject *obj;
19269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19270 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19271 Py_INCREF(obj);
19272 return Py_BuildValue((char *)"");
19273 }
19274 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19275 PyObject *resultobj;
19276 int arg1 = (int) 0 ;
19277 wxNcPaintEvent *result;
19278 PyObject * obj0 = 0 ;
19279 char *kwnames[] = {
19280 (char *) "winid", NULL
19281 };
19282
19283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19284 if (obj0) {
19285 {
19286 arg1 = (int)(SWIG_As_int(obj0));
19287 if (SWIG_arg_fail(1)) SWIG_fail;
19288 }
19289 }
19290 {
19291 PyThreadState* __tstate = wxPyBeginAllowThreads();
19292 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19293
19294 wxPyEndAllowThreads(__tstate);
19295 if (PyErr_Occurred()) SWIG_fail;
19296 }
19297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19298 return resultobj;
19299 fail:
19300 return NULL;
19301 }
19302
19303
19304 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19305 PyObject *obj;
19306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19307 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19308 Py_INCREF(obj);
19309 return Py_BuildValue((char *)"");
19310 }
19311 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19312 PyObject *resultobj;
19313 int arg1 = (int) 0 ;
19314 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19315 wxEraseEvent *result;
19316 PyObject * obj0 = 0 ;
19317 PyObject * obj1 = 0 ;
19318 char *kwnames[] = {
19319 (char *) "Id",(char *) "dc", NULL
19320 };
19321
19322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19323 if (obj0) {
19324 {
19325 arg1 = (int)(SWIG_As_int(obj0));
19326 if (SWIG_arg_fail(1)) SWIG_fail;
19327 }
19328 }
19329 if (obj1) {
19330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19331 if (SWIG_arg_fail(2)) SWIG_fail;
19332 }
19333 {
19334 PyThreadState* __tstate = wxPyBeginAllowThreads();
19335 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19336
19337 wxPyEndAllowThreads(__tstate);
19338 if (PyErr_Occurred()) SWIG_fail;
19339 }
19340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19341 return resultobj;
19342 fail:
19343 return NULL;
19344 }
19345
19346
19347 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19348 PyObject *resultobj;
19349 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19350 wxDC *result;
19351 PyObject * obj0 = 0 ;
19352 char *kwnames[] = {
19353 (char *) "self", NULL
19354 };
19355
19356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19358 if (SWIG_arg_fail(1)) SWIG_fail;
19359 {
19360 PyThreadState* __tstate = wxPyBeginAllowThreads();
19361 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19362
19363 wxPyEndAllowThreads(__tstate);
19364 if (PyErr_Occurred()) SWIG_fail;
19365 }
19366 {
19367 resultobj = wxPyMake_wxObject(result, 0);
19368 }
19369 return resultobj;
19370 fail:
19371 return NULL;
19372 }
19373
19374
19375 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19376 PyObject *obj;
19377 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19378 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19379 Py_INCREF(obj);
19380 return Py_BuildValue((char *)"");
19381 }
19382 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19383 PyObject *resultobj;
19384 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19385 int arg2 = (int) 0 ;
19386 wxFocusEvent *result;
19387 PyObject * obj0 = 0 ;
19388 PyObject * obj1 = 0 ;
19389 char *kwnames[] = {
19390 (char *) "type",(char *) "winid", NULL
19391 };
19392
19393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19394 if (obj0) {
19395 {
19396 arg1 = (wxEventType)(SWIG_As_int(obj0));
19397 if (SWIG_arg_fail(1)) SWIG_fail;
19398 }
19399 }
19400 if (obj1) {
19401 {
19402 arg2 = (int)(SWIG_As_int(obj1));
19403 if (SWIG_arg_fail(2)) SWIG_fail;
19404 }
19405 }
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19409
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19414 return resultobj;
19415 fail:
19416 return NULL;
19417 }
19418
19419
19420 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19421 PyObject *resultobj;
19422 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19423 wxWindow *result;
19424 PyObject * obj0 = 0 ;
19425 char *kwnames[] = {
19426 (char *) "self", NULL
19427 };
19428
19429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19431 if (SWIG_arg_fail(1)) SWIG_fail;
19432 {
19433 PyThreadState* __tstate = wxPyBeginAllowThreads();
19434 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19435
19436 wxPyEndAllowThreads(__tstate);
19437 if (PyErr_Occurred()) SWIG_fail;
19438 }
19439 {
19440 resultobj = wxPyMake_wxObject(result, 0);
19441 }
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19449 PyObject *resultobj;
19450 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19451 wxWindow *arg2 = (wxWindow *) 0 ;
19452 PyObject * obj0 = 0 ;
19453 PyObject * obj1 = 0 ;
19454 char *kwnames[] = {
19455 (char *) "self",(char *) "win", NULL
19456 };
19457
19458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19460 if (SWIG_arg_fail(1)) SWIG_fail;
19461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19462 if (SWIG_arg_fail(2)) SWIG_fail;
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 (arg1)->SetWindow(arg2);
19466
19467 wxPyEndAllowThreads(__tstate);
19468 if (PyErr_Occurred()) SWIG_fail;
19469 }
19470 Py_INCREF(Py_None); resultobj = Py_None;
19471 return resultobj;
19472 fail:
19473 return NULL;
19474 }
19475
19476
19477 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19478 PyObject *obj;
19479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19480 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19481 Py_INCREF(obj);
19482 return Py_BuildValue((char *)"");
19483 }
19484 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19485 PyObject *resultobj;
19486 wxWindow *arg1 = (wxWindow *) NULL ;
19487 wxChildFocusEvent *result;
19488 PyObject * obj0 = 0 ;
19489 char *kwnames[] = {
19490 (char *) "win", NULL
19491 };
19492
19493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19494 if (obj0) {
19495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19496 if (SWIG_arg_fail(1)) SWIG_fail;
19497 }
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19501
19502 wxPyEndAllowThreads(__tstate);
19503 if (PyErr_Occurred()) SWIG_fail;
19504 }
19505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19506 return resultobj;
19507 fail:
19508 return NULL;
19509 }
19510
19511
19512 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19513 PyObject *resultobj;
19514 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19515 wxWindow *result;
19516 PyObject * obj0 = 0 ;
19517 char *kwnames[] = {
19518 (char *) "self", NULL
19519 };
19520
19521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19523 if (SWIG_arg_fail(1)) SWIG_fail;
19524 {
19525 PyThreadState* __tstate = wxPyBeginAllowThreads();
19526 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19527
19528 wxPyEndAllowThreads(__tstate);
19529 if (PyErr_Occurred()) SWIG_fail;
19530 }
19531 {
19532 resultobj = wxPyMake_wxObject(result, 0);
19533 }
19534 return resultobj;
19535 fail:
19536 return NULL;
19537 }
19538
19539
19540 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19541 PyObject *obj;
19542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19543 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19544 Py_INCREF(obj);
19545 return Py_BuildValue((char *)"");
19546 }
19547 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19548 PyObject *resultobj;
19549 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19550 bool arg2 = (bool) true ;
19551 int arg3 = (int) 0 ;
19552 wxActivateEvent *result;
19553 PyObject * obj0 = 0 ;
19554 PyObject * obj1 = 0 ;
19555 PyObject * obj2 = 0 ;
19556 char *kwnames[] = {
19557 (char *) "type",(char *) "active",(char *) "Id", NULL
19558 };
19559
19560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19561 if (obj0) {
19562 {
19563 arg1 = (wxEventType)(SWIG_As_int(obj0));
19564 if (SWIG_arg_fail(1)) SWIG_fail;
19565 }
19566 }
19567 if (obj1) {
19568 {
19569 arg2 = (bool)(SWIG_As_bool(obj1));
19570 if (SWIG_arg_fail(2)) SWIG_fail;
19571 }
19572 }
19573 if (obj2) {
19574 {
19575 arg3 = (int)(SWIG_As_int(obj2));
19576 if (SWIG_arg_fail(3)) SWIG_fail;
19577 }
19578 }
19579 {
19580 PyThreadState* __tstate = wxPyBeginAllowThreads();
19581 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19582
19583 wxPyEndAllowThreads(__tstate);
19584 if (PyErr_Occurred()) SWIG_fail;
19585 }
19586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19587 return resultobj;
19588 fail:
19589 return NULL;
19590 }
19591
19592
19593 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19594 PyObject *resultobj;
19595 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19596 bool result;
19597 PyObject * obj0 = 0 ;
19598 char *kwnames[] = {
19599 (char *) "self", NULL
19600 };
19601
19602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19604 if (SWIG_arg_fail(1)) SWIG_fail;
19605 {
19606 PyThreadState* __tstate = wxPyBeginAllowThreads();
19607 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19608
19609 wxPyEndAllowThreads(__tstate);
19610 if (PyErr_Occurred()) SWIG_fail;
19611 }
19612 {
19613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19614 }
19615 return resultobj;
19616 fail:
19617 return NULL;
19618 }
19619
19620
19621 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19622 PyObject *obj;
19623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19624 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19625 Py_INCREF(obj);
19626 return Py_BuildValue((char *)"");
19627 }
19628 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19629 PyObject *resultobj;
19630 int arg1 = (int) 0 ;
19631 wxInitDialogEvent *result;
19632 PyObject * obj0 = 0 ;
19633 char *kwnames[] = {
19634 (char *) "Id", NULL
19635 };
19636
19637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19638 if (obj0) {
19639 {
19640 arg1 = (int)(SWIG_As_int(obj0));
19641 if (SWIG_arg_fail(1)) SWIG_fail;
19642 }
19643 }
19644 {
19645 PyThreadState* __tstate = wxPyBeginAllowThreads();
19646 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19647
19648 wxPyEndAllowThreads(__tstate);
19649 if (PyErr_Occurred()) SWIG_fail;
19650 }
19651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19652 return resultobj;
19653 fail:
19654 return NULL;
19655 }
19656
19657
19658 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19659 PyObject *obj;
19660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19661 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19662 Py_INCREF(obj);
19663 return Py_BuildValue((char *)"");
19664 }
19665 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19666 PyObject *resultobj;
19667 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19668 int arg2 = (int) 0 ;
19669 wxMenu *arg3 = (wxMenu *) NULL ;
19670 wxMenuEvent *result;
19671 PyObject * obj0 = 0 ;
19672 PyObject * obj1 = 0 ;
19673 PyObject * obj2 = 0 ;
19674 char *kwnames[] = {
19675 (char *) "type",(char *) "winid",(char *) "menu", NULL
19676 };
19677
19678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19679 if (obj0) {
19680 {
19681 arg1 = (wxEventType)(SWIG_As_int(obj0));
19682 if (SWIG_arg_fail(1)) SWIG_fail;
19683 }
19684 }
19685 if (obj1) {
19686 {
19687 arg2 = (int)(SWIG_As_int(obj1));
19688 if (SWIG_arg_fail(2)) SWIG_fail;
19689 }
19690 }
19691 if (obj2) {
19692 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19693 if (SWIG_arg_fail(3)) SWIG_fail;
19694 }
19695 {
19696 PyThreadState* __tstate = wxPyBeginAllowThreads();
19697 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19698
19699 wxPyEndAllowThreads(__tstate);
19700 if (PyErr_Occurred()) SWIG_fail;
19701 }
19702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19703 return resultobj;
19704 fail:
19705 return NULL;
19706 }
19707
19708
19709 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19710 PyObject *resultobj;
19711 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19712 int result;
19713 PyObject * obj0 = 0 ;
19714 char *kwnames[] = {
19715 (char *) "self", NULL
19716 };
19717
19718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19720 if (SWIG_arg_fail(1)) SWIG_fail;
19721 {
19722 PyThreadState* __tstate = wxPyBeginAllowThreads();
19723 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19724
19725 wxPyEndAllowThreads(__tstate);
19726 if (PyErr_Occurred()) SWIG_fail;
19727 }
19728 {
19729 resultobj = SWIG_From_int((int)(result));
19730 }
19731 return resultobj;
19732 fail:
19733 return NULL;
19734 }
19735
19736
19737 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19738 PyObject *resultobj;
19739 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19740 bool result;
19741 PyObject * obj0 = 0 ;
19742 char *kwnames[] = {
19743 (char *) "self", NULL
19744 };
19745
19746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19748 if (SWIG_arg_fail(1)) SWIG_fail;
19749 {
19750 PyThreadState* __tstate = wxPyBeginAllowThreads();
19751 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19752
19753 wxPyEndAllowThreads(__tstate);
19754 if (PyErr_Occurred()) SWIG_fail;
19755 }
19756 {
19757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19758 }
19759 return resultobj;
19760 fail:
19761 return NULL;
19762 }
19763
19764
19765 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19766 PyObject *resultobj;
19767 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19768 wxMenu *result;
19769 PyObject * obj0 = 0 ;
19770 char *kwnames[] = {
19771 (char *) "self", NULL
19772 };
19773
19774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19776 if (SWIG_arg_fail(1)) SWIG_fail;
19777 {
19778 PyThreadState* __tstate = wxPyBeginAllowThreads();
19779 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19780
19781 wxPyEndAllowThreads(__tstate);
19782 if (PyErr_Occurred()) SWIG_fail;
19783 }
19784 {
19785 resultobj = wxPyMake_wxObject(result, 0);
19786 }
19787 return resultobj;
19788 fail:
19789 return NULL;
19790 }
19791
19792
19793 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19794 PyObject *obj;
19795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19796 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19797 Py_INCREF(obj);
19798 return Py_BuildValue((char *)"");
19799 }
19800 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19801 PyObject *resultobj;
19802 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19803 int arg2 = (int) 0 ;
19804 wxCloseEvent *result;
19805 PyObject * obj0 = 0 ;
19806 PyObject * obj1 = 0 ;
19807 char *kwnames[] = {
19808 (char *) "type",(char *) "winid", NULL
19809 };
19810
19811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19812 if (obj0) {
19813 {
19814 arg1 = (wxEventType)(SWIG_As_int(obj0));
19815 if (SWIG_arg_fail(1)) SWIG_fail;
19816 }
19817 }
19818 if (obj1) {
19819 {
19820 arg2 = (int)(SWIG_As_int(obj1));
19821 if (SWIG_arg_fail(2)) SWIG_fail;
19822 }
19823 }
19824 {
19825 PyThreadState* __tstate = wxPyBeginAllowThreads();
19826 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19827
19828 wxPyEndAllowThreads(__tstate);
19829 if (PyErr_Occurred()) SWIG_fail;
19830 }
19831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19832 return resultobj;
19833 fail:
19834 return NULL;
19835 }
19836
19837
19838 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19839 PyObject *resultobj;
19840 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19841 bool arg2 ;
19842 PyObject * obj0 = 0 ;
19843 PyObject * obj1 = 0 ;
19844 char *kwnames[] = {
19845 (char *) "self",(char *) "logOff", NULL
19846 };
19847
19848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19850 if (SWIG_arg_fail(1)) SWIG_fail;
19851 {
19852 arg2 = (bool)(SWIG_As_bool(obj1));
19853 if (SWIG_arg_fail(2)) SWIG_fail;
19854 }
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 (arg1)->SetLoggingOff(arg2);
19858
19859 wxPyEndAllowThreads(__tstate);
19860 if (PyErr_Occurred()) SWIG_fail;
19861 }
19862 Py_INCREF(Py_None); resultobj = Py_None;
19863 return resultobj;
19864 fail:
19865 return NULL;
19866 }
19867
19868
19869 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19870 PyObject *resultobj;
19871 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19872 bool result;
19873 PyObject * obj0 = 0 ;
19874 char *kwnames[] = {
19875 (char *) "self", NULL
19876 };
19877
19878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19880 if (SWIG_arg_fail(1)) SWIG_fail;
19881 {
19882 PyThreadState* __tstate = wxPyBeginAllowThreads();
19883 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19884
19885 wxPyEndAllowThreads(__tstate);
19886 if (PyErr_Occurred()) SWIG_fail;
19887 }
19888 {
19889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19890 }
19891 return resultobj;
19892 fail:
19893 return NULL;
19894 }
19895
19896
19897 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19898 PyObject *resultobj;
19899 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19900 bool arg2 = (bool) true ;
19901 PyObject * obj0 = 0 ;
19902 PyObject * obj1 = 0 ;
19903 char *kwnames[] = {
19904 (char *) "self",(char *) "veto", NULL
19905 };
19906
19907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19909 if (SWIG_arg_fail(1)) SWIG_fail;
19910 if (obj1) {
19911 {
19912 arg2 = (bool)(SWIG_As_bool(obj1));
19913 if (SWIG_arg_fail(2)) SWIG_fail;
19914 }
19915 }
19916 {
19917 PyThreadState* __tstate = wxPyBeginAllowThreads();
19918 (arg1)->Veto(arg2);
19919
19920 wxPyEndAllowThreads(__tstate);
19921 if (PyErr_Occurred()) SWIG_fail;
19922 }
19923 Py_INCREF(Py_None); resultobj = Py_None;
19924 return resultobj;
19925 fail:
19926 return NULL;
19927 }
19928
19929
19930 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj;
19932 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19933 bool arg2 ;
19934 PyObject * obj0 = 0 ;
19935 PyObject * obj1 = 0 ;
19936 char *kwnames[] = {
19937 (char *) "self",(char *) "canVeto", NULL
19938 };
19939
19940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19942 if (SWIG_arg_fail(1)) SWIG_fail;
19943 {
19944 arg2 = (bool)(SWIG_As_bool(obj1));
19945 if (SWIG_arg_fail(2)) SWIG_fail;
19946 }
19947 {
19948 PyThreadState* __tstate = wxPyBeginAllowThreads();
19949 (arg1)->SetCanVeto(arg2);
19950
19951 wxPyEndAllowThreads(__tstate);
19952 if (PyErr_Occurred()) SWIG_fail;
19953 }
19954 Py_INCREF(Py_None); resultobj = Py_None;
19955 return resultobj;
19956 fail:
19957 return NULL;
19958 }
19959
19960
19961 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19962 PyObject *resultobj;
19963 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19964 bool result;
19965 PyObject * obj0 = 0 ;
19966 char *kwnames[] = {
19967 (char *) "self", NULL
19968 };
19969
19970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19972 if (SWIG_arg_fail(1)) SWIG_fail;
19973 {
19974 PyThreadState* __tstate = wxPyBeginAllowThreads();
19975 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19976
19977 wxPyEndAllowThreads(__tstate);
19978 if (PyErr_Occurred()) SWIG_fail;
19979 }
19980 {
19981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19982 }
19983 return resultobj;
19984 fail:
19985 return NULL;
19986 }
19987
19988
19989 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19990 PyObject *resultobj;
19991 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19992 bool result;
19993 PyObject * obj0 = 0 ;
19994 char *kwnames[] = {
19995 (char *) "self", NULL
19996 };
19997
19998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20000 if (SWIG_arg_fail(1)) SWIG_fail;
20001 {
20002 PyThreadState* __tstate = wxPyBeginAllowThreads();
20003 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20004
20005 wxPyEndAllowThreads(__tstate);
20006 if (PyErr_Occurred()) SWIG_fail;
20007 }
20008 {
20009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20010 }
20011 return resultobj;
20012 fail:
20013 return NULL;
20014 }
20015
20016
20017 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20018 PyObject *obj;
20019 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20020 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20021 Py_INCREF(obj);
20022 return Py_BuildValue((char *)"");
20023 }
20024 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20025 PyObject *resultobj;
20026 int arg1 = (int) 0 ;
20027 bool arg2 = (bool) false ;
20028 wxShowEvent *result;
20029 PyObject * obj0 = 0 ;
20030 PyObject * obj1 = 0 ;
20031 char *kwnames[] = {
20032 (char *) "winid",(char *) "show", NULL
20033 };
20034
20035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20036 if (obj0) {
20037 {
20038 arg1 = (int)(SWIG_As_int(obj0));
20039 if (SWIG_arg_fail(1)) SWIG_fail;
20040 }
20041 }
20042 if (obj1) {
20043 {
20044 arg2 = (bool)(SWIG_As_bool(obj1));
20045 if (SWIG_arg_fail(2)) SWIG_fail;
20046 }
20047 }
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20051
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20063 PyObject *resultobj;
20064 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20065 bool arg2 ;
20066 PyObject * obj0 = 0 ;
20067 PyObject * obj1 = 0 ;
20068 char *kwnames[] = {
20069 (char *) "self",(char *) "show", NULL
20070 };
20071
20072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20074 if (SWIG_arg_fail(1)) SWIG_fail;
20075 {
20076 arg2 = (bool)(SWIG_As_bool(obj1));
20077 if (SWIG_arg_fail(2)) SWIG_fail;
20078 }
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 (arg1)->SetShow(arg2);
20082
20083 wxPyEndAllowThreads(__tstate);
20084 if (PyErr_Occurred()) SWIG_fail;
20085 }
20086 Py_INCREF(Py_None); resultobj = Py_None;
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20094 PyObject *resultobj;
20095 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20096 bool result;
20097 PyObject * obj0 = 0 ;
20098 char *kwnames[] = {
20099 (char *) "self", NULL
20100 };
20101
20102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20104 if (SWIG_arg_fail(1)) SWIG_fail;
20105 {
20106 PyThreadState* __tstate = wxPyBeginAllowThreads();
20107 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20108
20109 wxPyEndAllowThreads(__tstate);
20110 if (PyErr_Occurred()) SWIG_fail;
20111 }
20112 {
20113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20114 }
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20122 PyObject *obj;
20123 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20124 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20125 Py_INCREF(obj);
20126 return Py_BuildValue((char *)"");
20127 }
20128 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20129 PyObject *resultobj;
20130 int arg1 = (int) 0 ;
20131 bool arg2 = (bool) true ;
20132 wxIconizeEvent *result;
20133 PyObject * obj0 = 0 ;
20134 PyObject * obj1 = 0 ;
20135 char *kwnames[] = {
20136 (char *) "id",(char *) "iconized", NULL
20137 };
20138
20139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20140 if (obj0) {
20141 {
20142 arg1 = (int)(SWIG_As_int(obj0));
20143 if (SWIG_arg_fail(1)) SWIG_fail;
20144 }
20145 }
20146 if (obj1) {
20147 {
20148 arg2 = (bool)(SWIG_As_bool(obj1));
20149 if (SWIG_arg_fail(2)) SWIG_fail;
20150 }
20151 }
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20155
20156 wxPyEndAllowThreads(__tstate);
20157 if (PyErr_Occurred()) SWIG_fail;
20158 }
20159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20167 PyObject *resultobj;
20168 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20169 bool result;
20170 PyObject * obj0 = 0 ;
20171 char *kwnames[] = {
20172 (char *) "self", NULL
20173 };
20174
20175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20177 if (SWIG_arg_fail(1)) SWIG_fail;
20178 {
20179 PyThreadState* __tstate = wxPyBeginAllowThreads();
20180 result = (bool)(arg1)->Iconized();
20181
20182 wxPyEndAllowThreads(__tstate);
20183 if (PyErr_Occurred()) SWIG_fail;
20184 }
20185 {
20186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20187 }
20188 return resultobj;
20189 fail:
20190 return NULL;
20191 }
20192
20193
20194 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20195 PyObject *obj;
20196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20197 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20198 Py_INCREF(obj);
20199 return Py_BuildValue((char *)"");
20200 }
20201 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20202 PyObject *resultobj;
20203 int arg1 = (int) 0 ;
20204 wxMaximizeEvent *result;
20205 PyObject * obj0 = 0 ;
20206 char *kwnames[] = {
20207 (char *) "id", NULL
20208 };
20209
20210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20211 if (obj0) {
20212 {
20213 arg1 = (int)(SWIG_As_int(obj0));
20214 if (SWIG_arg_fail(1)) SWIG_fail;
20215 }
20216 }
20217 {
20218 PyThreadState* __tstate = wxPyBeginAllowThreads();
20219 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20220
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20232 PyObject *obj;
20233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20234 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20235 Py_INCREF(obj);
20236 return Py_BuildValue((char *)"");
20237 }
20238 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20239 PyObject *resultobj;
20240 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20241 wxPoint result;
20242 PyObject * obj0 = 0 ;
20243 char *kwnames[] = {
20244 (char *) "self", NULL
20245 };
20246
20247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20249 if (SWIG_arg_fail(1)) SWIG_fail;
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 result = (arg1)->GetPosition();
20253
20254 wxPyEndAllowThreads(__tstate);
20255 if (PyErr_Occurred()) SWIG_fail;
20256 }
20257 {
20258 wxPoint * resultptr;
20259 resultptr = new wxPoint((wxPoint &)(result));
20260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20261 }
20262 return resultobj;
20263 fail:
20264 return NULL;
20265 }
20266
20267
20268 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20269 PyObject *resultobj;
20270 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20271 int result;
20272 PyObject * obj0 = 0 ;
20273 char *kwnames[] = {
20274 (char *) "self", NULL
20275 };
20276
20277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20279 if (SWIG_arg_fail(1)) SWIG_fail;
20280 {
20281 PyThreadState* __tstate = wxPyBeginAllowThreads();
20282 result = (int)(arg1)->GetNumberOfFiles();
20283
20284 wxPyEndAllowThreads(__tstate);
20285 if (PyErr_Occurred()) SWIG_fail;
20286 }
20287 {
20288 resultobj = SWIG_From_int((int)(result));
20289 }
20290 return resultobj;
20291 fail:
20292 return NULL;
20293 }
20294
20295
20296 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20297 PyObject *resultobj;
20298 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20299 PyObject *result;
20300 PyObject * obj0 = 0 ;
20301 char *kwnames[] = {
20302 (char *) "self", NULL
20303 };
20304
20305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20307 if (SWIG_arg_fail(1)) SWIG_fail;
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20311
20312 wxPyEndAllowThreads(__tstate);
20313 if (PyErr_Occurred()) SWIG_fail;
20314 }
20315 resultobj = result;
20316 return resultobj;
20317 fail:
20318 return NULL;
20319 }
20320
20321
20322 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20323 PyObject *obj;
20324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20325 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20326 Py_INCREF(obj);
20327 return Py_BuildValue((char *)"");
20328 }
20329 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj;
20331 int arg1 = (int) 0 ;
20332 wxUpdateUIEvent *result;
20333 PyObject * obj0 = 0 ;
20334 char *kwnames[] = {
20335 (char *) "commandId", NULL
20336 };
20337
20338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20339 if (obj0) {
20340 {
20341 arg1 = (int)(SWIG_As_int(obj0));
20342 if (SWIG_arg_fail(1)) SWIG_fail;
20343 }
20344 }
20345 {
20346 PyThreadState* __tstate = wxPyBeginAllowThreads();
20347 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20348
20349 wxPyEndAllowThreads(__tstate);
20350 if (PyErr_Occurred()) SWIG_fail;
20351 }
20352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20353 return resultobj;
20354 fail:
20355 return NULL;
20356 }
20357
20358
20359 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20360 PyObject *resultobj;
20361 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20362 bool result;
20363 PyObject * obj0 = 0 ;
20364 char *kwnames[] = {
20365 (char *) "self", NULL
20366 };
20367
20368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20370 if (SWIG_arg_fail(1)) SWIG_fail;
20371 {
20372 PyThreadState* __tstate = wxPyBeginAllowThreads();
20373 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20374
20375 wxPyEndAllowThreads(__tstate);
20376 if (PyErr_Occurred()) SWIG_fail;
20377 }
20378 {
20379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20380 }
20381 return resultobj;
20382 fail:
20383 return NULL;
20384 }
20385
20386
20387 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20388 PyObject *resultobj;
20389 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20390 bool result;
20391 PyObject * obj0 = 0 ;
20392 char *kwnames[] = {
20393 (char *) "self", NULL
20394 };
20395
20396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20398 if (SWIG_arg_fail(1)) SWIG_fail;
20399 {
20400 PyThreadState* __tstate = wxPyBeginAllowThreads();
20401 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20402
20403 wxPyEndAllowThreads(__tstate);
20404 if (PyErr_Occurred()) SWIG_fail;
20405 }
20406 {
20407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20408 }
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20416 PyObject *resultobj;
20417 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20418 wxString result;
20419 PyObject * obj0 = 0 ;
20420 char *kwnames[] = {
20421 (char *) "self", NULL
20422 };
20423
20424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20426 if (SWIG_arg_fail(1)) SWIG_fail;
20427 {
20428 PyThreadState* __tstate = wxPyBeginAllowThreads();
20429 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20430
20431 wxPyEndAllowThreads(__tstate);
20432 if (PyErr_Occurred()) SWIG_fail;
20433 }
20434 {
20435 #if wxUSE_UNICODE
20436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20437 #else
20438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20439 #endif
20440 }
20441 return resultobj;
20442 fail:
20443 return NULL;
20444 }
20445
20446
20447 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20448 PyObject *resultobj;
20449 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20450 bool result;
20451 PyObject * obj0 = 0 ;
20452 char *kwnames[] = {
20453 (char *) "self", NULL
20454 };
20455
20456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20458 if (SWIG_arg_fail(1)) SWIG_fail;
20459 {
20460 PyThreadState* __tstate = wxPyBeginAllowThreads();
20461 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20462
20463 wxPyEndAllowThreads(__tstate);
20464 if (PyErr_Occurred()) SWIG_fail;
20465 }
20466 {
20467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20468 }
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20476 PyObject *resultobj;
20477 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20478 bool result;
20479 PyObject * obj0 = 0 ;
20480 char *kwnames[] = {
20481 (char *) "self", NULL
20482 };
20483
20484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20486 if (SWIG_arg_fail(1)) SWIG_fail;
20487 {
20488 PyThreadState* __tstate = wxPyBeginAllowThreads();
20489 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20490
20491 wxPyEndAllowThreads(__tstate);
20492 if (PyErr_Occurred()) SWIG_fail;
20493 }
20494 {
20495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20496 }
20497 return resultobj;
20498 fail:
20499 return NULL;
20500 }
20501
20502
20503 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20504 PyObject *resultobj;
20505 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20506 bool result;
20507 PyObject * obj0 = 0 ;
20508 char *kwnames[] = {
20509 (char *) "self", NULL
20510 };
20511
20512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20514 if (SWIG_arg_fail(1)) SWIG_fail;
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20518
20519 wxPyEndAllowThreads(__tstate);
20520 if (PyErr_Occurred()) SWIG_fail;
20521 }
20522 {
20523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20524 }
20525 return resultobj;
20526 fail:
20527 return NULL;
20528 }
20529
20530
20531 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20532 PyObject *resultobj;
20533 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20534 bool arg2 ;
20535 PyObject * obj0 = 0 ;
20536 PyObject * obj1 = 0 ;
20537 char *kwnames[] = {
20538 (char *) "self",(char *) "check", NULL
20539 };
20540
20541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20543 if (SWIG_arg_fail(1)) SWIG_fail;
20544 {
20545 arg2 = (bool)(SWIG_As_bool(obj1));
20546 if (SWIG_arg_fail(2)) SWIG_fail;
20547 }
20548 {
20549 PyThreadState* __tstate = wxPyBeginAllowThreads();
20550 (arg1)->Check(arg2);
20551
20552 wxPyEndAllowThreads(__tstate);
20553 if (PyErr_Occurred()) SWIG_fail;
20554 }
20555 Py_INCREF(Py_None); resultobj = Py_None;
20556 return resultobj;
20557 fail:
20558 return NULL;
20559 }
20560
20561
20562 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20563 PyObject *resultobj;
20564 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20565 bool arg2 ;
20566 PyObject * obj0 = 0 ;
20567 PyObject * obj1 = 0 ;
20568 char *kwnames[] = {
20569 (char *) "self",(char *) "enable", NULL
20570 };
20571
20572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20574 if (SWIG_arg_fail(1)) SWIG_fail;
20575 {
20576 arg2 = (bool)(SWIG_As_bool(obj1));
20577 if (SWIG_arg_fail(2)) SWIG_fail;
20578 }
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 (arg1)->Enable(arg2);
20582
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 Py_INCREF(Py_None); resultobj = Py_None;
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20594 PyObject *resultobj;
20595 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20596 wxString *arg2 = 0 ;
20597 bool temp2 = false ;
20598 PyObject * obj0 = 0 ;
20599 PyObject * obj1 = 0 ;
20600 char *kwnames[] = {
20601 (char *) "self",(char *) "text", NULL
20602 };
20603
20604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20606 if (SWIG_arg_fail(1)) SWIG_fail;
20607 {
20608 arg2 = wxString_in_helper(obj1);
20609 if (arg2 == NULL) SWIG_fail;
20610 temp2 = true;
20611 }
20612 {
20613 PyThreadState* __tstate = wxPyBeginAllowThreads();
20614 (arg1)->SetText((wxString const &)*arg2);
20615
20616 wxPyEndAllowThreads(__tstate);
20617 if (PyErr_Occurred()) SWIG_fail;
20618 }
20619 Py_INCREF(Py_None); resultobj = Py_None;
20620 {
20621 if (temp2)
20622 delete arg2;
20623 }
20624 return resultobj;
20625 fail:
20626 {
20627 if (temp2)
20628 delete arg2;
20629 }
20630 return NULL;
20631 }
20632
20633
20634 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20635 PyObject *resultobj;
20636 long arg1 ;
20637 PyObject * obj0 = 0 ;
20638 char *kwnames[] = {
20639 (char *) "updateInterval", NULL
20640 };
20641
20642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20643 {
20644 arg1 = (long)(SWIG_As_long(obj0));
20645 if (SWIG_arg_fail(1)) SWIG_fail;
20646 }
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 wxUpdateUIEvent::SetUpdateInterval(arg1);
20650
20651 wxPyEndAllowThreads(__tstate);
20652 if (PyErr_Occurred()) SWIG_fail;
20653 }
20654 Py_INCREF(Py_None); resultobj = Py_None;
20655 return resultobj;
20656 fail:
20657 return NULL;
20658 }
20659
20660
20661 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20662 PyObject *resultobj;
20663 long result;
20664 char *kwnames[] = {
20665 NULL
20666 };
20667
20668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20669 {
20670 PyThreadState* __tstate = wxPyBeginAllowThreads();
20671 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20672
20673 wxPyEndAllowThreads(__tstate);
20674 if (PyErr_Occurred()) SWIG_fail;
20675 }
20676 {
20677 resultobj = SWIG_From_long((long)(result));
20678 }
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20686 PyObject *resultobj;
20687 wxWindow *arg1 = (wxWindow *) 0 ;
20688 bool result;
20689 PyObject * obj0 = 0 ;
20690 char *kwnames[] = {
20691 (char *) "win", NULL
20692 };
20693
20694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20696 if (SWIG_arg_fail(1)) SWIG_fail;
20697 {
20698 PyThreadState* __tstate = wxPyBeginAllowThreads();
20699 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20700
20701 wxPyEndAllowThreads(__tstate);
20702 if (PyErr_Occurred()) SWIG_fail;
20703 }
20704 {
20705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20706 }
20707 return resultobj;
20708 fail:
20709 return NULL;
20710 }
20711
20712
20713 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20714 PyObject *resultobj;
20715 char *kwnames[] = {
20716 NULL
20717 };
20718
20719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20720 {
20721 PyThreadState* __tstate = wxPyBeginAllowThreads();
20722 wxUpdateUIEvent::ResetUpdateTime();
20723
20724 wxPyEndAllowThreads(__tstate);
20725 if (PyErr_Occurred()) SWIG_fail;
20726 }
20727 Py_INCREF(Py_None); resultobj = Py_None;
20728 return resultobj;
20729 fail:
20730 return NULL;
20731 }
20732
20733
20734 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20735 PyObject *resultobj;
20736 wxUpdateUIMode arg1 ;
20737 PyObject * obj0 = 0 ;
20738 char *kwnames[] = {
20739 (char *) "mode", NULL
20740 };
20741
20742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20743 {
20744 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20745 if (SWIG_arg_fail(1)) SWIG_fail;
20746 }
20747 {
20748 PyThreadState* __tstate = wxPyBeginAllowThreads();
20749 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20750
20751 wxPyEndAllowThreads(__tstate);
20752 if (PyErr_Occurred()) SWIG_fail;
20753 }
20754 Py_INCREF(Py_None); resultobj = Py_None;
20755 return resultobj;
20756 fail:
20757 return NULL;
20758 }
20759
20760
20761 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20762 PyObject *resultobj;
20763 wxUpdateUIMode result;
20764 char *kwnames[] = {
20765 NULL
20766 };
20767
20768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20769 {
20770 PyThreadState* __tstate = wxPyBeginAllowThreads();
20771 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20772
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 resultobj = SWIG_From_int((result));
20777 return resultobj;
20778 fail:
20779 return NULL;
20780 }
20781
20782
20783 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20784 PyObject *obj;
20785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20786 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20787 Py_INCREF(obj);
20788 return Py_BuildValue((char *)"");
20789 }
20790 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20791 PyObject *resultobj;
20792 wxSysColourChangedEvent *result;
20793 char *kwnames[] = {
20794 NULL
20795 };
20796
20797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20798 {
20799 PyThreadState* __tstate = wxPyBeginAllowThreads();
20800 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20801
20802 wxPyEndAllowThreads(__tstate);
20803 if (PyErr_Occurred()) SWIG_fail;
20804 }
20805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20806 return resultobj;
20807 fail:
20808 return NULL;
20809 }
20810
20811
20812 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20813 PyObject *obj;
20814 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20815 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20816 Py_INCREF(obj);
20817 return Py_BuildValue((char *)"");
20818 }
20819 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20820 PyObject *resultobj;
20821 int arg1 = (int) 0 ;
20822 wxWindow *arg2 = (wxWindow *) NULL ;
20823 wxMouseCaptureChangedEvent *result;
20824 PyObject * obj0 = 0 ;
20825 PyObject * obj1 = 0 ;
20826 char *kwnames[] = {
20827 (char *) "winid",(char *) "gainedCapture", NULL
20828 };
20829
20830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20831 if (obj0) {
20832 {
20833 arg1 = (int)(SWIG_As_int(obj0));
20834 if (SWIG_arg_fail(1)) SWIG_fail;
20835 }
20836 }
20837 if (obj1) {
20838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20839 if (SWIG_arg_fail(2)) SWIG_fail;
20840 }
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20844
20845 wxPyEndAllowThreads(__tstate);
20846 if (PyErr_Occurred()) SWIG_fail;
20847 }
20848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20849 return resultobj;
20850 fail:
20851 return NULL;
20852 }
20853
20854
20855 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20856 PyObject *resultobj;
20857 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20858 wxWindow *result;
20859 PyObject * obj0 = 0 ;
20860 char *kwnames[] = {
20861 (char *) "self", NULL
20862 };
20863
20864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20866 if (SWIG_arg_fail(1)) SWIG_fail;
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20870
20871 wxPyEndAllowThreads(__tstate);
20872 if (PyErr_Occurred()) SWIG_fail;
20873 }
20874 {
20875 resultobj = wxPyMake_wxObject(result, 0);
20876 }
20877 return resultobj;
20878 fail:
20879 return NULL;
20880 }
20881
20882
20883 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20884 PyObject *obj;
20885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20886 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20887 Py_INCREF(obj);
20888 return Py_BuildValue((char *)"");
20889 }
20890 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20891 PyObject *resultobj;
20892 wxDisplayChangedEvent *result;
20893 char *kwnames[] = {
20894 NULL
20895 };
20896
20897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20898 {
20899 PyThreadState* __tstate = wxPyBeginAllowThreads();
20900 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20901
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20906 return resultobj;
20907 fail:
20908 return NULL;
20909 }
20910
20911
20912 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20913 PyObject *obj;
20914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20915 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20916 Py_INCREF(obj);
20917 return Py_BuildValue((char *)"");
20918 }
20919 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20920 PyObject *resultobj;
20921 int arg1 = (int) 0 ;
20922 wxPaletteChangedEvent *result;
20923 PyObject * obj0 = 0 ;
20924 char *kwnames[] = {
20925 (char *) "id", NULL
20926 };
20927
20928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20929 if (obj0) {
20930 {
20931 arg1 = (int)(SWIG_As_int(obj0));
20932 if (SWIG_arg_fail(1)) SWIG_fail;
20933 }
20934 }
20935 {
20936 PyThreadState* __tstate = wxPyBeginAllowThreads();
20937 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20938
20939 wxPyEndAllowThreads(__tstate);
20940 if (PyErr_Occurred()) SWIG_fail;
20941 }
20942 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20950 PyObject *resultobj;
20951 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20952 wxWindow *arg2 = (wxWindow *) 0 ;
20953 PyObject * obj0 = 0 ;
20954 PyObject * obj1 = 0 ;
20955 char *kwnames[] = {
20956 (char *) "self",(char *) "win", NULL
20957 };
20958
20959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20961 if (SWIG_arg_fail(1)) SWIG_fail;
20962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20963 if (SWIG_arg_fail(2)) SWIG_fail;
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 (arg1)->SetChangedWindow(arg2);
20967
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 Py_INCREF(Py_None); resultobj = Py_None;
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20979 PyObject *resultobj;
20980 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20981 wxWindow *result;
20982 PyObject * obj0 = 0 ;
20983 char *kwnames[] = {
20984 (char *) "self", NULL
20985 };
20986
20987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20989 if (SWIG_arg_fail(1)) SWIG_fail;
20990 {
20991 PyThreadState* __tstate = wxPyBeginAllowThreads();
20992 result = (wxWindow *)(arg1)->GetChangedWindow();
20993
20994 wxPyEndAllowThreads(__tstate);
20995 if (PyErr_Occurred()) SWIG_fail;
20996 }
20997 {
20998 resultobj = wxPyMake_wxObject(result, 0);
20999 }
21000 return resultobj;
21001 fail:
21002 return NULL;
21003 }
21004
21005
21006 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21007 PyObject *obj;
21008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21009 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21010 Py_INCREF(obj);
21011 return Py_BuildValue((char *)"");
21012 }
21013 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21014 PyObject *resultobj;
21015 int arg1 = (int) 0 ;
21016 wxQueryNewPaletteEvent *result;
21017 PyObject * obj0 = 0 ;
21018 char *kwnames[] = {
21019 (char *) "winid", NULL
21020 };
21021
21022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21023 if (obj0) {
21024 {
21025 arg1 = (int)(SWIG_As_int(obj0));
21026 if (SWIG_arg_fail(1)) SWIG_fail;
21027 }
21028 }
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21032
21033 wxPyEndAllowThreads(__tstate);
21034 if (PyErr_Occurred()) SWIG_fail;
21035 }
21036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21044 PyObject *resultobj;
21045 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21046 bool arg2 ;
21047 PyObject * obj0 = 0 ;
21048 PyObject * obj1 = 0 ;
21049 char *kwnames[] = {
21050 (char *) "self",(char *) "realized", NULL
21051 };
21052
21053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21055 if (SWIG_arg_fail(1)) SWIG_fail;
21056 {
21057 arg2 = (bool)(SWIG_As_bool(obj1));
21058 if (SWIG_arg_fail(2)) SWIG_fail;
21059 }
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 (arg1)->SetPaletteRealized(arg2);
21063
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 Py_INCREF(Py_None); resultobj = Py_None;
21068 return resultobj;
21069 fail:
21070 return NULL;
21071 }
21072
21073
21074 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21075 PyObject *resultobj;
21076 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21077 bool result;
21078 PyObject * obj0 = 0 ;
21079 char *kwnames[] = {
21080 (char *) "self", NULL
21081 };
21082
21083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21085 if (SWIG_arg_fail(1)) SWIG_fail;
21086 {
21087 PyThreadState* __tstate = wxPyBeginAllowThreads();
21088 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21089
21090 wxPyEndAllowThreads(__tstate);
21091 if (PyErr_Occurred()) SWIG_fail;
21092 }
21093 {
21094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21095 }
21096 return resultobj;
21097 fail:
21098 return NULL;
21099 }
21100
21101
21102 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21103 PyObject *obj;
21104 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21105 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21106 Py_INCREF(obj);
21107 return Py_BuildValue((char *)"");
21108 }
21109 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21110 PyObject *resultobj;
21111 wxNavigationKeyEvent *result;
21112 char *kwnames[] = {
21113 NULL
21114 };
21115
21116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21117 {
21118 PyThreadState* __tstate = wxPyBeginAllowThreads();
21119 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21120
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21125 return resultobj;
21126 fail:
21127 return NULL;
21128 }
21129
21130
21131 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21132 PyObject *resultobj;
21133 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21134 bool result;
21135 PyObject * obj0 = 0 ;
21136 char *kwnames[] = {
21137 (char *) "self", NULL
21138 };
21139
21140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21142 if (SWIG_arg_fail(1)) SWIG_fail;
21143 {
21144 PyThreadState* __tstate = wxPyBeginAllowThreads();
21145 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21146
21147 wxPyEndAllowThreads(__tstate);
21148 if (PyErr_Occurred()) SWIG_fail;
21149 }
21150 {
21151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21152 }
21153 return resultobj;
21154 fail:
21155 return NULL;
21156 }
21157
21158
21159 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21160 PyObject *resultobj;
21161 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21162 bool arg2 ;
21163 PyObject * obj0 = 0 ;
21164 PyObject * obj1 = 0 ;
21165 char *kwnames[] = {
21166 (char *) "self",(char *) "forward", NULL
21167 };
21168
21169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21171 if (SWIG_arg_fail(1)) SWIG_fail;
21172 {
21173 arg2 = (bool)(SWIG_As_bool(obj1));
21174 if (SWIG_arg_fail(2)) SWIG_fail;
21175 }
21176 {
21177 PyThreadState* __tstate = wxPyBeginAllowThreads();
21178 (arg1)->SetDirection(arg2);
21179
21180 wxPyEndAllowThreads(__tstate);
21181 if (PyErr_Occurred()) SWIG_fail;
21182 }
21183 Py_INCREF(Py_None); resultobj = Py_None;
21184 return resultobj;
21185 fail:
21186 return NULL;
21187 }
21188
21189
21190 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21191 PyObject *resultobj;
21192 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21193 bool result;
21194 PyObject * obj0 = 0 ;
21195 char *kwnames[] = {
21196 (char *) "self", NULL
21197 };
21198
21199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21201 if (SWIG_arg_fail(1)) SWIG_fail;
21202 {
21203 PyThreadState* __tstate = wxPyBeginAllowThreads();
21204 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21205
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 {
21210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21211 }
21212 return resultobj;
21213 fail:
21214 return NULL;
21215 }
21216
21217
21218 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21219 PyObject *resultobj;
21220 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21221 bool arg2 ;
21222 PyObject * obj0 = 0 ;
21223 PyObject * obj1 = 0 ;
21224 char *kwnames[] = {
21225 (char *) "self",(char *) "ischange", NULL
21226 };
21227
21228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21230 if (SWIG_arg_fail(1)) SWIG_fail;
21231 {
21232 arg2 = (bool)(SWIG_As_bool(obj1));
21233 if (SWIG_arg_fail(2)) SWIG_fail;
21234 }
21235 {
21236 PyThreadState* __tstate = wxPyBeginAllowThreads();
21237 (arg1)->SetWindowChange(arg2);
21238
21239 wxPyEndAllowThreads(__tstate);
21240 if (PyErr_Occurred()) SWIG_fail;
21241 }
21242 Py_INCREF(Py_None); resultobj = Py_None;
21243 return resultobj;
21244 fail:
21245 return NULL;
21246 }
21247
21248
21249 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21250 PyObject *resultobj;
21251 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21252 bool result;
21253 PyObject * obj0 = 0 ;
21254 char *kwnames[] = {
21255 (char *) "self", NULL
21256 };
21257
21258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21260 if (SWIG_arg_fail(1)) SWIG_fail;
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21264
21265 wxPyEndAllowThreads(__tstate);
21266 if (PyErr_Occurred()) SWIG_fail;
21267 }
21268 {
21269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21270 }
21271 return resultobj;
21272 fail:
21273 return NULL;
21274 }
21275
21276
21277 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21278 PyObject *resultobj;
21279 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21280 bool arg2 ;
21281 PyObject * obj0 = 0 ;
21282 PyObject * obj1 = 0 ;
21283 char *kwnames[] = {
21284 (char *) "self",(char *) "bIs", NULL
21285 };
21286
21287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21289 if (SWIG_arg_fail(1)) SWIG_fail;
21290 {
21291 arg2 = (bool)(SWIG_As_bool(obj1));
21292 if (SWIG_arg_fail(2)) SWIG_fail;
21293 }
21294 {
21295 PyThreadState* __tstate = wxPyBeginAllowThreads();
21296 (arg1)->SetFromTab(arg2);
21297
21298 wxPyEndAllowThreads(__tstate);
21299 if (PyErr_Occurred()) SWIG_fail;
21300 }
21301 Py_INCREF(Py_None); resultobj = Py_None;
21302 return resultobj;
21303 fail:
21304 return NULL;
21305 }
21306
21307
21308 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21309 PyObject *resultobj;
21310 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21311 long arg2 ;
21312 PyObject * obj0 = 0 ;
21313 PyObject * obj1 = 0 ;
21314 char *kwnames[] = {
21315 (char *) "self",(char *) "flags", NULL
21316 };
21317
21318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21320 if (SWIG_arg_fail(1)) SWIG_fail;
21321 {
21322 arg2 = (long)(SWIG_As_long(obj1));
21323 if (SWIG_arg_fail(2)) SWIG_fail;
21324 }
21325 {
21326 PyThreadState* __tstate = wxPyBeginAllowThreads();
21327 (arg1)->SetFlags(arg2);
21328
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 Py_INCREF(Py_None); resultobj = Py_None;
21333 return resultobj;
21334 fail:
21335 return NULL;
21336 }
21337
21338
21339 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj;
21341 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21342 wxWindow *result;
21343 PyObject * obj0 = 0 ;
21344 char *kwnames[] = {
21345 (char *) "self", NULL
21346 };
21347
21348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21350 if (SWIG_arg_fail(1)) SWIG_fail;
21351 {
21352 PyThreadState* __tstate = wxPyBeginAllowThreads();
21353 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21354
21355 wxPyEndAllowThreads(__tstate);
21356 if (PyErr_Occurred()) SWIG_fail;
21357 }
21358 {
21359 resultobj = wxPyMake_wxObject(result, 0);
21360 }
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj;
21369 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21370 wxWindow *arg2 = (wxWindow *) 0 ;
21371 PyObject * obj0 = 0 ;
21372 PyObject * obj1 = 0 ;
21373 char *kwnames[] = {
21374 (char *) "self",(char *) "win", NULL
21375 };
21376
21377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21379 if (SWIG_arg_fail(1)) SWIG_fail;
21380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21381 if (SWIG_arg_fail(2)) SWIG_fail;
21382 {
21383 PyThreadState* __tstate = wxPyBeginAllowThreads();
21384 (arg1)->SetCurrentFocus(arg2);
21385
21386 wxPyEndAllowThreads(__tstate);
21387 if (PyErr_Occurred()) SWIG_fail;
21388 }
21389 Py_INCREF(Py_None); resultobj = Py_None;
21390 return resultobj;
21391 fail:
21392 return NULL;
21393 }
21394
21395
21396 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21397 PyObject *obj;
21398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21399 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21400 Py_INCREF(obj);
21401 return Py_BuildValue((char *)"");
21402 }
21403 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21404 PyObject *resultobj;
21405 wxWindow *arg1 = (wxWindow *) NULL ;
21406 wxWindowCreateEvent *result;
21407 PyObject * obj0 = 0 ;
21408 char *kwnames[] = {
21409 (char *) "win", NULL
21410 };
21411
21412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21413 if (obj0) {
21414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21415 if (SWIG_arg_fail(1)) SWIG_fail;
21416 }
21417 {
21418 PyThreadState* __tstate = wxPyBeginAllowThreads();
21419 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21420
21421 wxPyEndAllowThreads(__tstate);
21422 if (PyErr_Occurred()) SWIG_fail;
21423 }
21424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21425 return resultobj;
21426 fail:
21427 return NULL;
21428 }
21429
21430
21431 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21432 PyObject *resultobj;
21433 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21434 wxWindow *result;
21435 PyObject * obj0 = 0 ;
21436 char *kwnames[] = {
21437 (char *) "self", NULL
21438 };
21439
21440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21442 if (SWIG_arg_fail(1)) SWIG_fail;
21443 {
21444 PyThreadState* __tstate = wxPyBeginAllowThreads();
21445 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21446
21447 wxPyEndAllowThreads(__tstate);
21448 if (PyErr_Occurred()) SWIG_fail;
21449 }
21450 {
21451 resultobj = wxPyMake_wxObject(result, 0);
21452 }
21453 return resultobj;
21454 fail:
21455 return NULL;
21456 }
21457
21458
21459 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21460 PyObject *obj;
21461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21462 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21463 Py_INCREF(obj);
21464 return Py_BuildValue((char *)"");
21465 }
21466 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21467 PyObject *resultobj;
21468 wxWindow *arg1 = (wxWindow *) NULL ;
21469 wxWindowDestroyEvent *result;
21470 PyObject * obj0 = 0 ;
21471 char *kwnames[] = {
21472 (char *) "win", NULL
21473 };
21474
21475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21476 if (obj0) {
21477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21478 if (SWIG_arg_fail(1)) SWIG_fail;
21479 }
21480 {
21481 PyThreadState* __tstate = wxPyBeginAllowThreads();
21482 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21483
21484 wxPyEndAllowThreads(__tstate);
21485 if (PyErr_Occurred()) SWIG_fail;
21486 }
21487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21495 PyObject *resultobj;
21496 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21497 wxWindow *result;
21498 PyObject * obj0 = 0 ;
21499 char *kwnames[] = {
21500 (char *) "self", NULL
21501 };
21502
21503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21505 if (SWIG_arg_fail(1)) SWIG_fail;
21506 {
21507 PyThreadState* __tstate = wxPyBeginAllowThreads();
21508 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21509
21510 wxPyEndAllowThreads(__tstate);
21511 if (PyErr_Occurred()) SWIG_fail;
21512 }
21513 {
21514 resultobj = wxPyMake_wxObject(result, 0);
21515 }
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21523 PyObject *obj;
21524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21525 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21526 Py_INCREF(obj);
21527 return Py_BuildValue((char *)"");
21528 }
21529 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21530 PyObject *resultobj;
21531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21532 int arg2 = (int) 0 ;
21533 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21534 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21535 wxContextMenuEvent *result;
21536 wxPoint temp3 ;
21537 PyObject * obj0 = 0 ;
21538 PyObject * obj1 = 0 ;
21539 PyObject * obj2 = 0 ;
21540 char *kwnames[] = {
21541 (char *) "type",(char *) "winid",(char *) "pt", NULL
21542 };
21543
21544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21545 if (obj0) {
21546 {
21547 arg1 = (wxEventType)(SWIG_As_int(obj0));
21548 if (SWIG_arg_fail(1)) SWIG_fail;
21549 }
21550 }
21551 if (obj1) {
21552 {
21553 arg2 = (int)(SWIG_As_int(obj1));
21554 if (SWIG_arg_fail(2)) SWIG_fail;
21555 }
21556 }
21557 if (obj2) {
21558 {
21559 arg3 = &temp3;
21560 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21561 }
21562 }
21563 {
21564 PyThreadState* __tstate = wxPyBeginAllowThreads();
21565 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21566
21567 wxPyEndAllowThreads(__tstate);
21568 if (PyErr_Occurred()) SWIG_fail;
21569 }
21570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21578 PyObject *resultobj;
21579 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21580 wxPoint *result;
21581 PyObject * obj0 = 0 ;
21582 char *kwnames[] = {
21583 (char *) "self", NULL
21584 };
21585
21586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21588 if (SWIG_arg_fail(1)) SWIG_fail;
21589 {
21590 PyThreadState* __tstate = wxPyBeginAllowThreads();
21591 {
21592 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21593 result = (wxPoint *) &_result_ref;
21594 }
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21607 PyObject *resultobj;
21608 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21609 wxPoint *arg2 = 0 ;
21610 wxPoint temp2 ;
21611 PyObject * obj0 = 0 ;
21612 PyObject * obj1 = 0 ;
21613 char *kwnames[] = {
21614 (char *) "self",(char *) "pos", NULL
21615 };
21616
21617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21619 if (SWIG_arg_fail(1)) SWIG_fail;
21620 {
21621 arg2 = &temp2;
21622 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21623 }
21624 {
21625 PyThreadState* __tstate = wxPyBeginAllowThreads();
21626 (arg1)->SetPosition((wxPoint const &)*arg2);
21627
21628 wxPyEndAllowThreads(__tstate);
21629 if (PyErr_Occurred()) SWIG_fail;
21630 }
21631 Py_INCREF(Py_None); resultobj = Py_None;
21632 return resultobj;
21633 fail:
21634 return NULL;
21635 }
21636
21637
21638 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21639 PyObject *obj;
21640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21641 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21642 Py_INCREF(obj);
21643 return Py_BuildValue((char *)"");
21644 }
21645 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21646 PyObject *resultobj;
21647 wxIdleEvent *result;
21648 char *kwnames[] = {
21649 NULL
21650 };
21651
21652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21653 {
21654 PyThreadState* __tstate = wxPyBeginAllowThreads();
21655 result = (wxIdleEvent *)new wxIdleEvent();
21656
21657 wxPyEndAllowThreads(__tstate);
21658 if (PyErr_Occurred()) SWIG_fail;
21659 }
21660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21668 PyObject *resultobj;
21669 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21670 bool arg2 = (bool) true ;
21671 PyObject * obj0 = 0 ;
21672 PyObject * obj1 = 0 ;
21673 char *kwnames[] = {
21674 (char *) "self",(char *) "needMore", NULL
21675 };
21676
21677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21679 if (SWIG_arg_fail(1)) SWIG_fail;
21680 if (obj1) {
21681 {
21682 arg2 = (bool)(SWIG_As_bool(obj1));
21683 if (SWIG_arg_fail(2)) SWIG_fail;
21684 }
21685 }
21686 {
21687 PyThreadState* __tstate = wxPyBeginAllowThreads();
21688 (arg1)->RequestMore(arg2);
21689
21690 wxPyEndAllowThreads(__tstate);
21691 if (PyErr_Occurred()) SWIG_fail;
21692 }
21693 Py_INCREF(Py_None); resultobj = Py_None;
21694 return resultobj;
21695 fail:
21696 return NULL;
21697 }
21698
21699
21700 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21701 PyObject *resultobj;
21702 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21703 bool result;
21704 PyObject * obj0 = 0 ;
21705 char *kwnames[] = {
21706 (char *) "self", NULL
21707 };
21708
21709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21711 if (SWIG_arg_fail(1)) SWIG_fail;
21712 {
21713 PyThreadState* __tstate = wxPyBeginAllowThreads();
21714 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21715
21716 wxPyEndAllowThreads(__tstate);
21717 if (PyErr_Occurred()) SWIG_fail;
21718 }
21719 {
21720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21721 }
21722 return resultobj;
21723 fail:
21724 return NULL;
21725 }
21726
21727
21728 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21729 PyObject *resultobj;
21730 wxIdleMode arg1 ;
21731 PyObject * obj0 = 0 ;
21732 char *kwnames[] = {
21733 (char *) "mode", NULL
21734 };
21735
21736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21737 {
21738 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21739 if (SWIG_arg_fail(1)) SWIG_fail;
21740 }
21741 {
21742 PyThreadState* __tstate = wxPyBeginAllowThreads();
21743 wxIdleEvent::SetMode((wxIdleMode )arg1);
21744
21745 wxPyEndAllowThreads(__tstate);
21746 if (PyErr_Occurred()) SWIG_fail;
21747 }
21748 Py_INCREF(Py_None); resultobj = Py_None;
21749 return resultobj;
21750 fail:
21751 return NULL;
21752 }
21753
21754
21755 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21756 PyObject *resultobj;
21757 wxIdleMode result;
21758 char *kwnames[] = {
21759 NULL
21760 };
21761
21762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21763 {
21764 PyThreadState* __tstate = wxPyBeginAllowThreads();
21765 result = (wxIdleMode)wxIdleEvent::GetMode();
21766
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 resultobj = SWIG_From_int((result));
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21778 PyObject *resultobj;
21779 wxWindow *arg1 = (wxWindow *) 0 ;
21780 bool result;
21781 PyObject * obj0 = 0 ;
21782 char *kwnames[] = {
21783 (char *) "win", NULL
21784 };
21785
21786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21788 if (SWIG_arg_fail(1)) SWIG_fail;
21789 {
21790 PyThreadState* __tstate = wxPyBeginAllowThreads();
21791 result = (bool)wxIdleEvent::CanSend(arg1);
21792
21793 wxPyEndAllowThreads(__tstate);
21794 if (PyErr_Occurred()) SWIG_fail;
21795 }
21796 {
21797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21798 }
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21806 PyObject *obj;
21807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21808 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21809 Py_INCREF(obj);
21810 return Py_BuildValue((char *)"");
21811 }
21812 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21813 PyObject *resultobj;
21814 int arg1 = (int) 0 ;
21815 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21816 wxPyEvent *result;
21817 PyObject * obj0 = 0 ;
21818 PyObject * obj1 = 0 ;
21819 char *kwnames[] = {
21820 (char *) "winid",(char *) "commandType", NULL
21821 };
21822
21823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21824 if (obj0) {
21825 {
21826 arg1 = (int)(SWIG_As_int(obj0));
21827 if (SWIG_arg_fail(1)) SWIG_fail;
21828 }
21829 }
21830 if (obj1) {
21831 {
21832 arg2 = (wxEventType)(SWIG_As_int(obj1));
21833 if (SWIG_arg_fail(2)) SWIG_fail;
21834 }
21835 }
21836 {
21837 PyThreadState* __tstate = wxPyBeginAllowThreads();
21838 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21839
21840 wxPyEndAllowThreads(__tstate);
21841 if (PyErr_Occurred()) SWIG_fail;
21842 }
21843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21851 PyObject *resultobj;
21852 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21853 PyObject * obj0 = 0 ;
21854 char *kwnames[] = {
21855 (char *) "self", NULL
21856 };
21857
21858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21860 if (SWIG_arg_fail(1)) SWIG_fail;
21861 {
21862 PyThreadState* __tstate = wxPyBeginAllowThreads();
21863 delete arg1;
21864
21865 wxPyEndAllowThreads(__tstate);
21866 if (PyErr_Occurred()) SWIG_fail;
21867 }
21868 Py_INCREF(Py_None); resultobj = Py_None;
21869 return resultobj;
21870 fail:
21871 return NULL;
21872 }
21873
21874
21875 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21876 PyObject *resultobj;
21877 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21878 PyObject *arg2 = (PyObject *) 0 ;
21879 PyObject * obj0 = 0 ;
21880 PyObject * obj1 = 0 ;
21881 char *kwnames[] = {
21882 (char *) "self",(char *) "self", NULL
21883 };
21884
21885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21887 if (SWIG_arg_fail(1)) SWIG_fail;
21888 arg2 = obj1;
21889 {
21890 PyThreadState* __tstate = wxPyBeginAllowThreads();
21891 (arg1)->SetSelf(arg2);
21892
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 Py_INCREF(Py_None); resultobj = Py_None;
21897 return resultobj;
21898 fail:
21899 return NULL;
21900 }
21901
21902
21903 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21904 PyObject *resultobj;
21905 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21906 PyObject *result;
21907 PyObject * obj0 = 0 ;
21908 char *kwnames[] = {
21909 (char *) "self", NULL
21910 };
21911
21912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21914 if (SWIG_arg_fail(1)) SWIG_fail;
21915 {
21916 PyThreadState* __tstate = wxPyBeginAllowThreads();
21917 result = (PyObject *)(arg1)->GetSelf();
21918
21919 wxPyEndAllowThreads(__tstate);
21920 if (PyErr_Occurred()) SWIG_fail;
21921 }
21922 resultobj = result;
21923 return resultobj;
21924 fail:
21925 return NULL;
21926 }
21927
21928
21929 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21930 PyObject *obj;
21931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21932 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21933 Py_INCREF(obj);
21934 return Py_BuildValue((char *)"");
21935 }
21936 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21937 PyObject *resultobj;
21938 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21939 int arg2 = (int) 0 ;
21940 wxPyCommandEvent *result;
21941 PyObject * obj0 = 0 ;
21942 PyObject * obj1 = 0 ;
21943 char *kwnames[] = {
21944 (char *) "commandType",(char *) "id", NULL
21945 };
21946
21947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21948 if (obj0) {
21949 {
21950 arg1 = (wxEventType)(SWIG_As_int(obj0));
21951 if (SWIG_arg_fail(1)) SWIG_fail;
21952 }
21953 }
21954 if (obj1) {
21955 {
21956 arg2 = (int)(SWIG_As_int(obj1));
21957 if (SWIG_arg_fail(2)) SWIG_fail;
21958 }
21959 }
21960 {
21961 PyThreadState* __tstate = wxPyBeginAllowThreads();
21962 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21963
21964 wxPyEndAllowThreads(__tstate);
21965 if (PyErr_Occurred()) SWIG_fail;
21966 }
21967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21968 return resultobj;
21969 fail:
21970 return NULL;
21971 }
21972
21973
21974 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21975 PyObject *resultobj;
21976 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21977 PyObject * obj0 = 0 ;
21978 char *kwnames[] = {
21979 (char *) "self", NULL
21980 };
21981
21982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21984 if (SWIG_arg_fail(1)) SWIG_fail;
21985 {
21986 PyThreadState* __tstate = wxPyBeginAllowThreads();
21987 delete arg1;
21988
21989 wxPyEndAllowThreads(__tstate);
21990 if (PyErr_Occurred()) SWIG_fail;
21991 }
21992 Py_INCREF(Py_None); resultobj = Py_None;
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22000 PyObject *resultobj;
22001 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22002 PyObject *arg2 = (PyObject *) 0 ;
22003 PyObject * obj0 = 0 ;
22004 PyObject * obj1 = 0 ;
22005 char *kwnames[] = {
22006 (char *) "self",(char *) "self", NULL
22007 };
22008
22009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22011 if (SWIG_arg_fail(1)) SWIG_fail;
22012 arg2 = obj1;
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 (arg1)->SetSelf(arg2);
22016
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 Py_INCREF(Py_None); resultobj = Py_None;
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22028 PyObject *resultobj;
22029 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22030 PyObject *result;
22031 PyObject * obj0 = 0 ;
22032 char *kwnames[] = {
22033 (char *) "self", NULL
22034 };
22035
22036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22038 if (SWIG_arg_fail(1)) SWIG_fail;
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 result = (PyObject *)(arg1)->GetSelf();
22042
22043 wxPyEndAllowThreads(__tstate);
22044 if (PyErr_Occurred()) SWIG_fail;
22045 }
22046 resultobj = result;
22047 return resultobj;
22048 fail:
22049 return NULL;
22050 }
22051
22052
22053 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22054 PyObject *obj;
22055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22056 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22057 Py_INCREF(obj);
22058 return Py_BuildValue((char *)"");
22059 }
22060 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22061 PyObject *resultobj;
22062 wxWindow *arg1 = (wxWindow *) 0 ;
22063 wxDateTime *arg2 = 0 ;
22064 wxEventType arg3 ;
22065 wxDateEvent *result;
22066 PyObject * obj0 = 0 ;
22067 PyObject * obj1 = 0 ;
22068 PyObject * obj2 = 0 ;
22069 char *kwnames[] = {
22070 (char *) "win",(char *) "dt",(char *) "type", NULL
22071 };
22072
22073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22075 if (SWIG_arg_fail(1)) SWIG_fail;
22076 {
22077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22078 if (SWIG_arg_fail(2)) SWIG_fail;
22079 if (arg2 == NULL) {
22080 SWIG_null_ref("wxDateTime");
22081 }
22082 if (SWIG_arg_fail(2)) SWIG_fail;
22083 }
22084 {
22085 arg3 = (wxEventType)(SWIG_As_int(obj2));
22086 if (SWIG_arg_fail(3)) SWIG_fail;
22087 }
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22091
22092 wxPyEndAllowThreads(__tstate);
22093 if (PyErr_Occurred()) SWIG_fail;
22094 }
22095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22096 return resultobj;
22097 fail:
22098 return NULL;
22099 }
22100
22101
22102 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22103 PyObject *resultobj;
22104 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22105 wxDateTime *result;
22106 PyObject * obj0 = 0 ;
22107 char *kwnames[] = {
22108 (char *) "self", NULL
22109 };
22110
22111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22113 if (SWIG_arg_fail(1)) SWIG_fail;
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 {
22117 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22118 result = (wxDateTime *) &_result_ref;
22119 }
22120
22121 wxPyEndAllowThreads(__tstate);
22122 if (PyErr_Occurred()) SWIG_fail;
22123 }
22124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22125 return resultobj;
22126 fail:
22127 return NULL;
22128 }
22129
22130
22131 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22132 PyObject *resultobj;
22133 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22134 wxDateTime *arg2 = 0 ;
22135 PyObject * obj0 = 0 ;
22136 PyObject * obj1 = 0 ;
22137 char *kwnames[] = {
22138 (char *) "self",(char *) "date", NULL
22139 };
22140
22141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22143 if (SWIG_arg_fail(1)) SWIG_fail;
22144 {
22145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22146 if (SWIG_arg_fail(2)) SWIG_fail;
22147 if (arg2 == NULL) {
22148 SWIG_null_ref("wxDateTime");
22149 }
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 }
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 (arg1)->SetDate((wxDateTime const &)*arg2);
22155
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 Py_INCREF(Py_None); resultobj = Py_None;
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22167 PyObject *obj;
22168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22169 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22170 Py_INCREF(obj);
22171 return Py_BuildValue((char *)"");
22172 }
22173 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22174 PyObject *resultobj;
22175 wxPyApp *result;
22176 char *kwnames[] = {
22177 NULL
22178 };
22179
22180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22181 {
22182 PyThreadState* __tstate = wxPyBeginAllowThreads();
22183 result = (wxPyApp *)new_wxPyApp();
22184
22185 wxPyEndAllowThreads(__tstate);
22186 if (PyErr_Occurred()) SWIG_fail;
22187 }
22188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj;
22197 wxPyApp *arg1 = (wxPyApp *) 0 ;
22198 PyObject * obj0 = 0 ;
22199 char *kwnames[] = {
22200 (char *) "self", NULL
22201 };
22202
22203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22205 if (SWIG_arg_fail(1)) SWIG_fail;
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 delete arg1;
22209
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 Py_INCREF(Py_None); resultobj = Py_None;
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22221 PyObject *resultobj;
22222 wxPyApp *arg1 = (wxPyApp *) 0 ;
22223 PyObject *arg2 = (PyObject *) 0 ;
22224 PyObject *arg3 = (PyObject *) 0 ;
22225 PyObject * obj0 = 0 ;
22226 PyObject * obj1 = 0 ;
22227 PyObject * obj2 = 0 ;
22228 char *kwnames[] = {
22229 (char *) "self",(char *) "self",(char *) "_class", NULL
22230 };
22231
22232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22234 if (SWIG_arg_fail(1)) SWIG_fail;
22235 arg2 = obj1;
22236 arg3 = obj2;
22237 {
22238 PyThreadState* __tstate = wxPyBeginAllowThreads();
22239 (arg1)->_setCallbackInfo(arg2,arg3);
22240
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 Py_INCREF(Py_None); resultobj = Py_None;
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22252 PyObject *resultobj;
22253 wxPyApp *arg1 = (wxPyApp *) 0 ;
22254 wxString result;
22255 PyObject * obj0 = 0 ;
22256 char *kwnames[] = {
22257 (char *) "self", NULL
22258 };
22259
22260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22262 if (SWIG_arg_fail(1)) SWIG_fail;
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 result = ((wxPyApp const *)arg1)->GetAppName();
22266
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 {
22271 #if wxUSE_UNICODE
22272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22273 #else
22274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22275 #endif
22276 }
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22284 PyObject *resultobj;
22285 wxPyApp *arg1 = (wxPyApp *) 0 ;
22286 wxString *arg2 = 0 ;
22287 bool temp2 = false ;
22288 PyObject * obj0 = 0 ;
22289 PyObject * obj1 = 0 ;
22290 char *kwnames[] = {
22291 (char *) "self",(char *) "name", NULL
22292 };
22293
22294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22296 if (SWIG_arg_fail(1)) SWIG_fail;
22297 {
22298 arg2 = wxString_in_helper(obj1);
22299 if (arg2 == NULL) SWIG_fail;
22300 temp2 = true;
22301 }
22302 {
22303 PyThreadState* __tstate = wxPyBeginAllowThreads();
22304 (arg1)->SetAppName((wxString const &)*arg2);
22305
22306 wxPyEndAllowThreads(__tstate);
22307 if (PyErr_Occurred()) SWIG_fail;
22308 }
22309 Py_INCREF(Py_None); resultobj = Py_None;
22310 {
22311 if (temp2)
22312 delete arg2;
22313 }
22314 return resultobj;
22315 fail:
22316 {
22317 if (temp2)
22318 delete arg2;
22319 }
22320 return NULL;
22321 }
22322
22323
22324 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22325 PyObject *resultobj;
22326 wxPyApp *arg1 = (wxPyApp *) 0 ;
22327 wxString result;
22328 PyObject * obj0 = 0 ;
22329 char *kwnames[] = {
22330 (char *) "self", NULL
22331 };
22332
22333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22335 if (SWIG_arg_fail(1)) SWIG_fail;
22336 {
22337 PyThreadState* __tstate = wxPyBeginAllowThreads();
22338 result = ((wxPyApp const *)arg1)->GetClassName();
22339
22340 wxPyEndAllowThreads(__tstate);
22341 if (PyErr_Occurred()) SWIG_fail;
22342 }
22343 {
22344 #if wxUSE_UNICODE
22345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22346 #else
22347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22348 #endif
22349 }
22350 return resultobj;
22351 fail:
22352 return NULL;
22353 }
22354
22355
22356 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22357 PyObject *resultobj;
22358 wxPyApp *arg1 = (wxPyApp *) 0 ;
22359 wxString *arg2 = 0 ;
22360 bool temp2 = false ;
22361 PyObject * obj0 = 0 ;
22362 PyObject * obj1 = 0 ;
22363 char *kwnames[] = {
22364 (char *) "self",(char *) "name", NULL
22365 };
22366
22367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22369 if (SWIG_arg_fail(1)) SWIG_fail;
22370 {
22371 arg2 = wxString_in_helper(obj1);
22372 if (arg2 == NULL) SWIG_fail;
22373 temp2 = true;
22374 }
22375 {
22376 PyThreadState* __tstate = wxPyBeginAllowThreads();
22377 (arg1)->SetClassName((wxString const &)*arg2);
22378
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 Py_INCREF(Py_None); resultobj = Py_None;
22383 {
22384 if (temp2)
22385 delete arg2;
22386 }
22387 return resultobj;
22388 fail:
22389 {
22390 if (temp2)
22391 delete arg2;
22392 }
22393 return NULL;
22394 }
22395
22396
22397 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22398 PyObject *resultobj;
22399 wxPyApp *arg1 = (wxPyApp *) 0 ;
22400 wxString *result;
22401 PyObject * obj0 = 0 ;
22402 char *kwnames[] = {
22403 (char *) "self", NULL
22404 };
22405
22406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22408 if (SWIG_arg_fail(1)) SWIG_fail;
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 {
22412 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22413 result = (wxString *) &_result_ref;
22414 }
22415
22416 wxPyEndAllowThreads(__tstate);
22417 if (PyErr_Occurred()) SWIG_fail;
22418 }
22419 {
22420 #if wxUSE_UNICODE
22421 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22422 #else
22423 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22424 #endif
22425 }
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22433 PyObject *resultobj;
22434 wxPyApp *arg1 = (wxPyApp *) 0 ;
22435 wxString *arg2 = 0 ;
22436 bool temp2 = false ;
22437 PyObject * obj0 = 0 ;
22438 PyObject * obj1 = 0 ;
22439 char *kwnames[] = {
22440 (char *) "self",(char *) "name", NULL
22441 };
22442
22443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22445 if (SWIG_arg_fail(1)) SWIG_fail;
22446 {
22447 arg2 = wxString_in_helper(obj1);
22448 if (arg2 == NULL) SWIG_fail;
22449 temp2 = true;
22450 }
22451 {
22452 PyThreadState* __tstate = wxPyBeginAllowThreads();
22453 (arg1)->SetVendorName((wxString const &)*arg2);
22454
22455 wxPyEndAllowThreads(__tstate);
22456 if (PyErr_Occurred()) SWIG_fail;
22457 }
22458 Py_INCREF(Py_None); resultobj = Py_None;
22459 {
22460 if (temp2)
22461 delete arg2;
22462 }
22463 return resultobj;
22464 fail:
22465 {
22466 if (temp2)
22467 delete arg2;
22468 }
22469 return NULL;
22470 }
22471
22472
22473 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22474 PyObject *resultobj;
22475 wxPyApp *arg1 = (wxPyApp *) 0 ;
22476 wxAppTraits *result;
22477 PyObject * obj0 = 0 ;
22478 char *kwnames[] = {
22479 (char *) "self", NULL
22480 };
22481
22482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22484 if (SWIG_arg_fail(1)) SWIG_fail;
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 result = (wxAppTraits *)(arg1)->GetTraits();
22488
22489 wxPyEndAllowThreads(__tstate);
22490 if (PyErr_Occurred()) SWIG_fail;
22491 }
22492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22493 return resultobj;
22494 fail:
22495 return NULL;
22496 }
22497
22498
22499 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22500 PyObject *resultobj;
22501 wxPyApp *arg1 = (wxPyApp *) 0 ;
22502 PyObject * obj0 = 0 ;
22503 char *kwnames[] = {
22504 (char *) "self", NULL
22505 };
22506
22507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22509 if (SWIG_arg_fail(1)) SWIG_fail;
22510 {
22511 PyThreadState* __tstate = wxPyBeginAllowThreads();
22512 (arg1)->ProcessPendingEvents();
22513
22514 wxPyEndAllowThreads(__tstate);
22515 if (PyErr_Occurred()) SWIG_fail;
22516 }
22517 Py_INCREF(Py_None); resultobj = Py_None;
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22525 PyObject *resultobj;
22526 wxPyApp *arg1 = (wxPyApp *) 0 ;
22527 bool arg2 = (bool) false ;
22528 bool result;
22529 PyObject * obj0 = 0 ;
22530 PyObject * obj1 = 0 ;
22531 char *kwnames[] = {
22532 (char *) "self",(char *) "onlyIfNeeded", NULL
22533 };
22534
22535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22537 if (SWIG_arg_fail(1)) SWIG_fail;
22538 if (obj1) {
22539 {
22540 arg2 = (bool)(SWIG_As_bool(obj1));
22541 if (SWIG_arg_fail(2)) SWIG_fail;
22542 }
22543 }
22544 {
22545 PyThreadState* __tstate = wxPyBeginAllowThreads();
22546 result = (bool)(arg1)->Yield(arg2);
22547
22548 wxPyEndAllowThreads(__tstate);
22549 if (PyErr_Occurred()) SWIG_fail;
22550 }
22551 {
22552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22553 }
22554 return resultobj;
22555 fail:
22556 return NULL;
22557 }
22558
22559
22560 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22561 PyObject *resultobj;
22562 wxPyApp *arg1 = (wxPyApp *) 0 ;
22563 PyObject * obj0 = 0 ;
22564 char *kwnames[] = {
22565 (char *) "self", NULL
22566 };
22567
22568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22570 if (SWIG_arg_fail(1)) SWIG_fail;
22571 {
22572 PyThreadState* __tstate = wxPyBeginAllowThreads();
22573 (arg1)->WakeUpIdle();
22574
22575 wxPyEndAllowThreads(__tstate);
22576 if (PyErr_Occurred()) SWIG_fail;
22577 }
22578 Py_INCREF(Py_None); resultobj = Py_None;
22579 return resultobj;
22580 fail:
22581 return NULL;
22582 }
22583
22584
22585 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22586 PyObject *resultobj;
22587 bool result;
22588 char *kwnames[] = {
22589 NULL
22590 };
22591
22592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22593 {
22594 PyThreadState* __tstate = wxPyBeginAllowThreads();
22595 result = (bool)wxPyApp::IsMainLoopRunning();
22596
22597 wxPyEndAllowThreads(__tstate);
22598 if (PyErr_Occurred()) SWIG_fail;
22599 }
22600 {
22601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22602 }
22603 return resultobj;
22604 fail:
22605 return NULL;
22606 }
22607
22608
22609 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22610 PyObject *resultobj;
22611 wxPyApp *arg1 = (wxPyApp *) 0 ;
22612 int result;
22613 PyObject * obj0 = 0 ;
22614 char *kwnames[] = {
22615 (char *) "self", NULL
22616 };
22617
22618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22620 if (SWIG_arg_fail(1)) SWIG_fail;
22621 {
22622 PyThreadState* __tstate = wxPyBeginAllowThreads();
22623 result = (int)(arg1)->MainLoop();
22624
22625 wxPyEndAllowThreads(__tstate);
22626 if (PyErr_Occurred()) SWIG_fail;
22627 }
22628 {
22629 resultobj = SWIG_From_int((int)(result));
22630 }
22631 return resultobj;
22632 fail:
22633 return NULL;
22634 }
22635
22636
22637 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22638 PyObject *resultobj;
22639 wxPyApp *arg1 = (wxPyApp *) 0 ;
22640 PyObject * obj0 = 0 ;
22641 char *kwnames[] = {
22642 (char *) "self", NULL
22643 };
22644
22645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22647 if (SWIG_arg_fail(1)) SWIG_fail;
22648 {
22649 PyThreadState* __tstate = wxPyBeginAllowThreads();
22650 (arg1)->Exit();
22651
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 Py_INCREF(Py_None); resultobj = Py_None;
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22663 PyObject *resultobj;
22664 wxPyApp *arg1 = (wxPyApp *) 0 ;
22665 PyObject * obj0 = 0 ;
22666 char *kwnames[] = {
22667 (char *) "self", NULL
22668 };
22669
22670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22672 if (SWIG_arg_fail(1)) SWIG_fail;
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 (arg1)->ExitMainLoop();
22676
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 Py_INCREF(Py_None); resultobj = Py_None;
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22688 PyObject *resultobj;
22689 wxPyApp *arg1 = (wxPyApp *) 0 ;
22690 bool result;
22691 PyObject * obj0 = 0 ;
22692 char *kwnames[] = {
22693 (char *) "self", NULL
22694 };
22695
22696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22698 if (SWIG_arg_fail(1)) SWIG_fail;
22699 {
22700 PyThreadState* __tstate = wxPyBeginAllowThreads();
22701 result = (bool)(arg1)->Pending();
22702
22703 wxPyEndAllowThreads(__tstate);
22704 if (PyErr_Occurred()) SWIG_fail;
22705 }
22706 {
22707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22708 }
22709 return resultobj;
22710 fail:
22711 return NULL;
22712 }
22713
22714
22715 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22716 PyObject *resultobj;
22717 wxPyApp *arg1 = (wxPyApp *) 0 ;
22718 bool result;
22719 PyObject * obj0 = 0 ;
22720 char *kwnames[] = {
22721 (char *) "self", NULL
22722 };
22723
22724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22726 if (SWIG_arg_fail(1)) SWIG_fail;
22727 {
22728 PyThreadState* __tstate = wxPyBeginAllowThreads();
22729 result = (bool)(arg1)->Dispatch();
22730
22731 wxPyEndAllowThreads(__tstate);
22732 if (PyErr_Occurred()) SWIG_fail;
22733 }
22734 {
22735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22736 }
22737 return resultobj;
22738 fail:
22739 return NULL;
22740 }
22741
22742
22743 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22744 PyObject *resultobj;
22745 wxPyApp *arg1 = (wxPyApp *) 0 ;
22746 bool result;
22747 PyObject * obj0 = 0 ;
22748 char *kwnames[] = {
22749 (char *) "self", NULL
22750 };
22751
22752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22754 if (SWIG_arg_fail(1)) SWIG_fail;
22755 {
22756 PyThreadState* __tstate = wxPyBeginAllowThreads();
22757 result = (bool)(arg1)->ProcessIdle();
22758
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 {
22763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22764 }
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22772 PyObject *resultobj;
22773 wxPyApp *arg1 = (wxPyApp *) 0 ;
22774 wxWindow *arg2 = (wxWindow *) 0 ;
22775 wxIdleEvent *arg3 = 0 ;
22776 bool result;
22777 PyObject * obj0 = 0 ;
22778 PyObject * obj1 = 0 ;
22779 PyObject * obj2 = 0 ;
22780 char *kwnames[] = {
22781 (char *) "self",(char *) "win",(char *) "event", NULL
22782 };
22783
22784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22786 if (SWIG_arg_fail(1)) SWIG_fail;
22787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22788 if (SWIG_arg_fail(2)) SWIG_fail;
22789 {
22790 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22791 if (SWIG_arg_fail(3)) SWIG_fail;
22792 if (arg3 == NULL) {
22793 SWIG_null_ref("wxIdleEvent");
22794 }
22795 if (SWIG_arg_fail(3)) SWIG_fail;
22796 }
22797 {
22798 PyThreadState* __tstate = wxPyBeginAllowThreads();
22799 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22800
22801 wxPyEndAllowThreads(__tstate);
22802 if (PyErr_Occurred()) SWIG_fail;
22803 }
22804 {
22805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22806 }
22807 return resultobj;
22808 fail:
22809 return NULL;
22810 }
22811
22812
22813 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22814 PyObject *resultobj;
22815 wxPyApp *arg1 = (wxPyApp *) 0 ;
22816 bool result;
22817 PyObject * obj0 = 0 ;
22818 char *kwnames[] = {
22819 (char *) "self", NULL
22820 };
22821
22822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22824 if (SWIG_arg_fail(1)) SWIG_fail;
22825 {
22826 PyThreadState* __tstate = wxPyBeginAllowThreads();
22827 result = (bool)((wxPyApp const *)arg1)->IsActive();
22828
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 {
22833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22834 }
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22842 PyObject *resultobj;
22843 wxPyApp *arg1 = (wxPyApp *) 0 ;
22844 wxWindow *arg2 = (wxWindow *) 0 ;
22845 PyObject * obj0 = 0 ;
22846 PyObject * obj1 = 0 ;
22847 char *kwnames[] = {
22848 (char *) "self",(char *) "win", NULL
22849 };
22850
22851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22853 if (SWIG_arg_fail(1)) SWIG_fail;
22854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22855 if (SWIG_arg_fail(2)) SWIG_fail;
22856 {
22857 PyThreadState* __tstate = wxPyBeginAllowThreads();
22858 (arg1)->SetTopWindow(arg2);
22859
22860 wxPyEndAllowThreads(__tstate);
22861 if (PyErr_Occurred()) SWIG_fail;
22862 }
22863 Py_INCREF(Py_None); resultobj = Py_None;
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22871 PyObject *resultobj;
22872 wxPyApp *arg1 = (wxPyApp *) 0 ;
22873 wxWindow *result;
22874 PyObject * obj0 = 0 ;
22875 char *kwnames[] = {
22876 (char *) "self", NULL
22877 };
22878
22879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22881 if (SWIG_arg_fail(1)) SWIG_fail;
22882 {
22883 PyThreadState* __tstate = wxPyBeginAllowThreads();
22884 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22885
22886 wxPyEndAllowThreads(__tstate);
22887 if (PyErr_Occurred()) SWIG_fail;
22888 }
22889 {
22890 resultobj = wxPyMake_wxObject(result, 0);
22891 }
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22899 PyObject *resultobj;
22900 wxPyApp *arg1 = (wxPyApp *) 0 ;
22901 bool arg2 ;
22902 PyObject * obj0 = 0 ;
22903 PyObject * obj1 = 0 ;
22904 char *kwnames[] = {
22905 (char *) "self",(char *) "flag", NULL
22906 };
22907
22908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22910 if (SWIG_arg_fail(1)) SWIG_fail;
22911 {
22912 arg2 = (bool)(SWIG_As_bool(obj1));
22913 if (SWIG_arg_fail(2)) SWIG_fail;
22914 }
22915 {
22916 PyThreadState* __tstate = wxPyBeginAllowThreads();
22917 (arg1)->SetExitOnFrameDelete(arg2);
22918
22919 wxPyEndAllowThreads(__tstate);
22920 if (PyErr_Occurred()) SWIG_fail;
22921 }
22922 Py_INCREF(Py_None); resultobj = Py_None;
22923 return resultobj;
22924 fail:
22925 return NULL;
22926 }
22927
22928
22929 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22930 PyObject *resultobj;
22931 wxPyApp *arg1 = (wxPyApp *) 0 ;
22932 bool result;
22933 PyObject * obj0 = 0 ;
22934 char *kwnames[] = {
22935 (char *) "self", NULL
22936 };
22937
22938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22940 if (SWIG_arg_fail(1)) SWIG_fail;
22941 {
22942 PyThreadState* __tstate = wxPyBeginAllowThreads();
22943 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22944
22945 wxPyEndAllowThreads(__tstate);
22946 if (PyErr_Occurred()) SWIG_fail;
22947 }
22948 {
22949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22950 }
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22958 PyObject *resultobj;
22959 wxPyApp *arg1 = (wxPyApp *) 0 ;
22960 bool arg2 ;
22961 PyObject * obj0 = 0 ;
22962 PyObject * obj1 = 0 ;
22963 char *kwnames[] = {
22964 (char *) "self",(char *) "flag", NULL
22965 };
22966
22967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22969 if (SWIG_arg_fail(1)) SWIG_fail;
22970 {
22971 arg2 = (bool)(SWIG_As_bool(obj1));
22972 if (SWIG_arg_fail(2)) SWIG_fail;
22973 }
22974 {
22975 PyThreadState* __tstate = wxPyBeginAllowThreads();
22976 (arg1)->SetUseBestVisual(arg2);
22977
22978 wxPyEndAllowThreads(__tstate);
22979 if (PyErr_Occurred()) SWIG_fail;
22980 }
22981 Py_INCREF(Py_None); resultobj = Py_None;
22982 return resultobj;
22983 fail:
22984 return NULL;
22985 }
22986
22987
22988 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22989 PyObject *resultobj;
22990 wxPyApp *arg1 = (wxPyApp *) 0 ;
22991 bool result;
22992 PyObject * obj0 = 0 ;
22993 char *kwnames[] = {
22994 (char *) "self", NULL
22995 };
22996
22997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22999 if (SWIG_arg_fail(1)) SWIG_fail;
23000 {
23001 PyThreadState* __tstate = wxPyBeginAllowThreads();
23002 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23003
23004 wxPyEndAllowThreads(__tstate);
23005 if (PyErr_Occurred()) SWIG_fail;
23006 }
23007 {
23008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23009 }
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23017 PyObject *resultobj;
23018 wxPyApp *arg1 = (wxPyApp *) 0 ;
23019 int arg2 ;
23020 PyObject * obj0 = 0 ;
23021 PyObject * obj1 = 0 ;
23022 char *kwnames[] = {
23023 (char *) "self",(char *) "mode", NULL
23024 };
23025
23026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23028 if (SWIG_arg_fail(1)) SWIG_fail;
23029 {
23030 arg2 = (int)(SWIG_As_int(obj1));
23031 if (SWIG_arg_fail(2)) SWIG_fail;
23032 }
23033 {
23034 PyThreadState* __tstate = wxPyBeginAllowThreads();
23035 (arg1)->SetPrintMode(arg2);
23036
23037 wxPyEndAllowThreads(__tstate);
23038 if (PyErr_Occurred()) SWIG_fail;
23039 }
23040 Py_INCREF(Py_None); resultobj = Py_None;
23041 return resultobj;
23042 fail:
23043 return NULL;
23044 }
23045
23046
23047 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23048 PyObject *resultobj;
23049 wxPyApp *arg1 = (wxPyApp *) 0 ;
23050 int result;
23051 PyObject * obj0 = 0 ;
23052 char *kwnames[] = {
23053 (char *) "self", NULL
23054 };
23055
23056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23058 if (SWIG_arg_fail(1)) SWIG_fail;
23059 {
23060 PyThreadState* __tstate = wxPyBeginAllowThreads();
23061 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23062
23063 wxPyEndAllowThreads(__tstate);
23064 if (PyErr_Occurred()) SWIG_fail;
23065 }
23066 {
23067 resultobj = SWIG_From_int((int)(result));
23068 }
23069 return resultobj;
23070 fail:
23071 return NULL;
23072 }
23073
23074
23075 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23076 PyObject *resultobj;
23077 wxPyApp *arg1 = (wxPyApp *) 0 ;
23078 int arg2 ;
23079 PyObject * obj0 = 0 ;
23080 PyObject * obj1 = 0 ;
23081 char *kwnames[] = {
23082 (char *) "self",(char *) "mode", NULL
23083 };
23084
23085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23087 if (SWIG_arg_fail(1)) SWIG_fail;
23088 {
23089 arg2 = (int)(SWIG_As_int(obj1));
23090 if (SWIG_arg_fail(2)) SWIG_fail;
23091 }
23092 {
23093 PyThreadState* __tstate = wxPyBeginAllowThreads();
23094 (arg1)->SetAssertMode(arg2);
23095
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 Py_INCREF(Py_None); resultobj = Py_None;
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23107 PyObject *resultobj;
23108 wxPyApp *arg1 = (wxPyApp *) 0 ;
23109 int result;
23110 PyObject * obj0 = 0 ;
23111 char *kwnames[] = {
23112 (char *) "self", NULL
23113 };
23114
23115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23117 if (SWIG_arg_fail(1)) SWIG_fail;
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 result = (int)(arg1)->GetAssertMode();
23121
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 {
23126 resultobj = SWIG_From_int((int)(result));
23127 }
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23135 PyObject *resultobj;
23136 bool result;
23137 char *kwnames[] = {
23138 NULL
23139 };
23140
23141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23142 {
23143 PyThreadState* __tstate = wxPyBeginAllowThreads();
23144 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23145
23146 wxPyEndAllowThreads(__tstate);
23147 if (PyErr_Occurred()) SWIG_fail;
23148 }
23149 {
23150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23151 }
23152 return resultobj;
23153 fail:
23154 return NULL;
23155 }
23156
23157
23158 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23159 PyObject *resultobj;
23160 long result;
23161 char *kwnames[] = {
23162 NULL
23163 };
23164
23165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23166 {
23167 PyThreadState* __tstate = wxPyBeginAllowThreads();
23168 result = (long)wxPyApp::GetMacAboutMenuItemId();
23169
23170 wxPyEndAllowThreads(__tstate);
23171 if (PyErr_Occurred()) SWIG_fail;
23172 }
23173 {
23174 resultobj = SWIG_From_long((long)(result));
23175 }
23176 return resultobj;
23177 fail:
23178 return NULL;
23179 }
23180
23181
23182 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23183 PyObject *resultobj;
23184 long result;
23185 char *kwnames[] = {
23186 NULL
23187 };
23188
23189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23190 {
23191 PyThreadState* __tstate = wxPyBeginAllowThreads();
23192 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23193
23194 wxPyEndAllowThreads(__tstate);
23195 if (PyErr_Occurred()) SWIG_fail;
23196 }
23197 {
23198 resultobj = SWIG_From_long((long)(result));
23199 }
23200 return resultobj;
23201 fail:
23202 return NULL;
23203 }
23204
23205
23206 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23207 PyObject *resultobj;
23208 long result;
23209 char *kwnames[] = {
23210 NULL
23211 };
23212
23213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23214 {
23215 PyThreadState* __tstate = wxPyBeginAllowThreads();
23216 result = (long)wxPyApp::GetMacExitMenuItemId();
23217
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 {
23222 resultobj = SWIG_From_long((long)(result));
23223 }
23224 return resultobj;
23225 fail:
23226 return NULL;
23227 }
23228
23229
23230 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23231 PyObject *resultobj;
23232 wxString result;
23233 char *kwnames[] = {
23234 NULL
23235 };
23236
23237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23238 {
23239 PyThreadState* __tstate = wxPyBeginAllowThreads();
23240 result = wxPyApp::GetMacHelpMenuTitleName();
23241
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 {
23246 #if wxUSE_UNICODE
23247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23248 #else
23249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23250 #endif
23251 }
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj;
23260 bool arg1 ;
23261 PyObject * obj0 = 0 ;
23262 char *kwnames[] = {
23263 (char *) "val", NULL
23264 };
23265
23266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23267 {
23268 arg1 = (bool)(SWIG_As_bool(obj0));
23269 if (SWIG_arg_fail(1)) SWIG_fail;
23270 }
23271 {
23272 PyThreadState* __tstate = wxPyBeginAllowThreads();
23273 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23274
23275 wxPyEndAllowThreads(__tstate);
23276 if (PyErr_Occurred()) SWIG_fail;
23277 }
23278 Py_INCREF(Py_None); resultobj = Py_None;
23279 return resultobj;
23280 fail:
23281 return NULL;
23282 }
23283
23284
23285 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23286 PyObject *resultobj;
23287 long arg1 ;
23288 PyObject * obj0 = 0 ;
23289 char *kwnames[] = {
23290 (char *) "val", NULL
23291 };
23292
23293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23294 {
23295 arg1 = (long)(SWIG_As_long(obj0));
23296 if (SWIG_arg_fail(1)) SWIG_fail;
23297 }
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 wxPyApp::SetMacAboutMenuItemId(arg1);
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 Py_INCREF(Py_None); resultobj = Py_None;
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj;
23314 long arg1 ;
23315 PyObject * obj0 = 0 ;
23316 char *kwnames[] = {
23317 (char *) "val", NULL
23318 };
23319
23320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23321 {
23322 arg1 = (long)(SWIG_As_long(obj0));
23323 if (SWIG_arg_fail(1)) SWIG_fail;
23324 }
23325 {
23326 PyThreadState* __tstate = wxPyBeginAllowThreads();
23327 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23328
23329 wxPyEndAllowThreads(__tstate);
23330 if (PyErr_Occurred()) SWIG_fail;
23331 }
23332 Py_INCREF(Py_None); resultobj = Py_None;
23333 return resultobj;
23334 fail:
23335 return NULL;
23336 }
23337
23338
23339 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23340 PyObject *resultobj;
23341 long arg1 ;
23342 PyObject * obj0 = 0 ;
23343 char *kwnames[] = {
23344 (char *) "val", NULL
23345 };
23346
23347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23348 {
23349 arg1 = (long)(SWIG_As_long(obj0));
23350 if (SWIG_arg_fail(1)) SWIG_fail;
23351 }
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 wxPyApp::SetMacExitMenuItemId(arg1);
23355
23356 wxPyEndAllowThreads(__tstate);
23357 if (PyErr_Occurred()) SWIG_fail;
23358 }
23359 Py_INCREF(Py_None); resultobj = Py_None;
23360 return resultobj;
23361 fail:
23362 return NULL;
23363 }
23364
23365
23366 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23367 PyObject *resultobj;
23368 wxString *arg1 = 0 ;
23369 bool temp1 = false ;
23370 PyObject * obj0 = 0 ;
23371 char *kwnames[] = {
23372 (char *) "val", NULL
23373 };
23374
23375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23376 {
23377 arg1 = wxString_in_helper(obj0);
23378 if (arg1 == NULL) SWIG_fail;
23379 temp1 = true;
23380 }
23381 {
23382 PyThreadState* __tstate = wxPyBeginAllowThreads();
23383 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23384
23385 wxPyEndAllowThreads(__tstate);
23386 if (PyErr_Occurred()) SWIG_fail;
23387 }
23388 Py_INCREF(Py_None); resultobj = Py_None;
23389 {
23390 if (temp1)
23391 delete arg1;
23392 }
23393 return resultobj;
23394 fail:
23395 {
23396 if (temp1)
23397 delete arg1;
23398 }
23399 return NULL;
23400 }
23401
23402
23403 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23404 PyObject *resultobj;
23405 wxPyApp *arg1 = (wxPyApp *) 0 ;
23406 PyObject * obj0 = 0 ;
23407 char *kwnames[] = {
23408 (char *) "self", NULL
23409 };
23410
23411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23413 if (SWIG_arg_fail(1)) SWIG_fail;
23414 {
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 (arg1)->_BootstrapApp();
23417
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 Py_INCREF(Py_None); resultobj = Py_None;
23422 return resultobj;
23423 fail:
23424 return NULL;
23425 }
23426
23427
23428 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23429 PyObject *resultobj;
23430 int result;
23431 char *kwnames[] = {
23432 NULL
23433 };
23434
23435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23436 {
23437 PyThreadState* __tstate = wxPyBeginAllowThreads();
23438 result = (int)wxPyApp::GetComCtl32Version();
23439
23440 wxPyEndAllowThreads(__tstate);
23441 if (PyErr_Occurred()) SWIG_fail;
23442 }
23443 {
23444 resultobj = SWIG_From_int((int)(result));
23445 }
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23453 PyObject *obj;
23454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23455 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23456 Py_INCREF(obj);
23457 return Py_BuildValue((char *)"");
23458 }
23459 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23460 PyObject *resultobj;
23461 char *kwnames[] = {
23462 NULL
23463 };
23464
23465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23466 {
23467 PyThreadState* __tstate = wxPyBeginAllowThreads();
23468 wxExit();
23469
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 Py_INCREF(Py_None); resultobj = Py_None;
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj;
23482 bool result;
23483 char *kwnames[] = {
23484 NULL
23485 };
23486
23487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23488 {
23489 PyThreadState* __tstate = wxPyBeginAllowThreads();
23490 result = (bool)wxYield();
23491
23492 wxPyEndAllowThreads(__tstate);
23493 if (PyErr_Occurred()) SWIG_fail;
23494 }
23495 {
23496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23497 }
23498 return resultobj;
23499 fail:
23500 return NULL;
23501 }
23502
23503
23504 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23505 PyObject *resultobj;
23506 bool result;
23507 char *kwnames[] = {
23508 NULL
23509 };
23510
23511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23512 {
23513 PyThreadState* __tstate = wxPyBeginAllowThreads();
23514 result = (bool)wxYieldIfNeeded();
23515
23516 wxPyEndAllowThreads(__tstate);
23517 if (PyErr_Occurred()) SWIG_fail;
23518 }
23519 {
23520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23521 }
23522 return resultobj;
23523 fail:
23524 return NULL;
23525 }
23526
23527
23528 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23529 PyObject *resultobj;
23530 wxWindow *arg1 = (wxWindow *) NULL ;
23531 bool arg2 = (bool) false ;
23532 bool result;
23533 PyObject * obj0 = 0 ;
23534 PyObject * obj1 = 0 ;
23535 char *kwnames[] = {
23536 (char *) "win",(char *) "onlyIfNeeded", NULL
23537 };
23538
23539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23540 if (obj0) {
23541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23542 if (SWIG_arg_fail(1)) SWIG_fail;
23543 }
23544 if (obj1) {
23545 {
23546 arg2 = (bool)(SWIG_As_bool(obj1));
23547 if (SWIG_arg_fail(2)) SWIG_fail;
23548 }
23549 }
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 result = (bool)wxSafeYield(arg1,arg2);
23553
23554 wxPyEndAllowThreads(__tstate);
23555 if (PyErr_Occurred()) SWIG_fail;
23556 }
23557 {
23558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23559 }
23560 return resultobj;
23561 fail:
23562 return NULL;
23563 }
23564
23565
23566 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23567 PyObject *resultobj;
23568 char *kwnames[] = {
23569 NULL
23570 };
23571
23572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 wxWakeUpIdle();
23576
23577 wxPyEndAllowThreads(__tstate);
23578 if (PyErr_Occurred()) SWIG_fail;
23579 }
23580 Py_INCREF(Py_None); resultobj = Py_None;
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23588 PyObject *resultobj;
23589 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23590 wxEvent *arg2 = 0 ;
23591 PyObject * obj0 = 0 ;
23592 PyObject * obj1 = 0 ;
23593 char *kwnames[] = {
23594 (char *) "dest",(char *) "event", NULL
23595 };
23596
23597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23599 if (SWIG_arg_fail(1)) SWIG_fail;
23600 {
23601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23602 if (SWIG_arg_fail(2)) SWIG_fail;
23603 if (arg2 == NULL) {
23604 SWIG_null_ref("wxEvent");
23605 }
23606 if (SWIG_arg_fail(2)) SWIG_fail;
23607 }
23608 {
23609 PyThreadState* __tstate = wxPyBeginAllowThreads();
23610 wxPostEvent(arg1,*arg2);
23611
23612 wxPyEndAllowThreads(__tstate);
23613 if (PyErr_Occurred()) SWIG_fail;
23614 }
23615 Py_INCREF(Py_None); resultobj = Py_None;
23616 return resultobj;
23617 fail:
23618 return NULL;
23619 }
23620
23621
23622 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23623 PyObject *resultobj;
23624 char *kwnames[] = {
23625 NULL
23626 };
23627
23628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 wxApp_CleanUp();
23632
23633 wxPyEndAllowThreads(__tstate);
23634 if (PyErr_Occurred()) SWIG_fail;
23635 }
23636 Py_INCREF(Py_None); resultobj = Py_None;
23637 return resultobj;
23638 fail:
23639 return NULL;
23640 }
23641
23642
23643 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23644 PyObject *resultobj;
23645 wxPyApp *result;
23646 char *kwnames[] = {
23647 NULL
23648 };
23649
23650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23651 {
23652 PyThreadState* __tstate = wxPyBeginAllowThreads();
23653 result = (wxPyApp *)wxPyGetApp();
23654
23655 wxPyEndAllowThreads(__tstate);
23656 if (PyErr_Occurred()) SWIG_fail;
23657 }
23658 {
23659 resultobj = wxPyMake_wxObject(result, 0);
23660 }
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23668 PyObject *resultobj;
23669 char *arg1 = (char *) 0 ;
23670 PyObject * obj0 = 0 ;
23671 char *kwnames[] = {
23672 (char *) "encoding", NULL
23673 };
23674
23675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23676 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23677 SWIG_arg_fail(1);SWIG_fail;
23678 }
23679 {
23680 PyThreadState* __tstate = wxPyBeginAllowThreads();
23681 wxSetDefaultPyEncoding((char const *)arg1);
23682
23683 wxPyEndAllowThreads(__tstate);
23684 if (PyErr_Occurred()) SWIG_fail;
23685 }
23686 Py_INCREF(Py_None); resultobj = Py_None;
23687 return resultobj;
23688 fail:
23689 return NULL;
23690 }
23691
23692
23693 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23694 PyObject *resultobj;
23695 char *result;
23696 char *kwnames[] = {
23697 NULL
23698 };
23699
23700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 result = (char *)wxGetDefaultPyEncoding();
23704
23705 wxPyEndAllowThreads(__tstate);
23706 if (PyErr_Occurred()) SWIG_fail;
23707 }
23708 resultobj = SWIG_FromCharPtr(result);
23709 return resultobj;
23710 fail:
23711 return NULL;
23712 }
23713
23714
23715 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23716 PyObject *resultobj;
23717 wxEventLoop *result;
23718 char *kwnames[] = {
23719 NULL
23720 };
23721
23722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23723 {
23724 PyThreadState* __tstate = wxPyBeginAllowThreads();
23725 result = (wxEventLoop *)new wxEventLoop();
23726
23727 wxPyEndAllowThreads(__tstate);
23728 if (PyErr_Occurred()) SWIG_fail;
23729 }
23730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23738 PyObject *resultobj;
23739 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23740 PyObject * obj0 = 0 ;
23741 char *kwnames[] = {
23742 (char *) "self", NULL
23743 };
23744
23745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23747 if (SWIG_arg_fail(1)) SWIG_fail;
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 delete arg1;
23751
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 Py_INCREF(Py_None); resultobj = Py_None;
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23763 PyObject *resultobj;
23764 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23765 int result;
23766 PyObject * obj0 = 0 ;
23767 char *kwnames[] = {
23768 (char *) "self", NULL
23769 };
23770
23771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23773 if (SWIG_arg_fail(1)) SWIG_fail;
23774 {
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 result = (int)(arg1)->Run();
23777
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 {
23782 resultobj = SWIG_From_int((int)(result));
23783 }
23784 return resultobj;
23785 fail:
23786 return NULL;
23787 }
23788
23789
23790 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23791 PyObject *resultobj;
23792 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23793 int arg2 = (int) 0 ;
23794 PyObject * obj0 = 0 ;
23795 PyObject * obj1 = 0 ;
23796 char *kwnames[] = {
23797 (char *) "self",(char *) "rc", NULL
23798 };
23799
23800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23802 if (SWIG_arg_fail(1)) SWIG_fail;
23803 if (obj1) {
23804 {
23805 arg2 = (int)(SWIG_As_int(obj1));
23806 if (SWIG_arg_fail(2)) SWIG_fail;
23807 }
23808 }
23809 {
23810 PyThreadState* __tstate = wxPyBeginAllowThreads();
23811 (arg1)->Exit(arg2);
23812
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 Py_INCREF(Py_None); resultobj = Py_None;
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23824 PyObject *resultobj;
23825 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23826 bool result;
23827 PyObject * obj0 = 0 ;
23828 char *kwnames[] = {
23829 (char *) "self", NULL
23830 };
23831
23832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23834 if (SWIG_arg_fail(1)) SWIG_fail;
23835 {
23836 PyThreadState* __tstate = wxPyBeginAllowThreads();
23837 result = (bool)((wxEventLoop const *)arg1)->Pending();
23838
23839 wxPyEndAllowThreads(__tstate);
23840 if (PyErr_Occurred()) SWIG_fail;
23841 }
23842 {
23843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23844 }
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23852 PyObject *resultobj;
23853 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23854 bool result;
23855 PyObject * obj0 = 0 ;
23856 char *kwnames[] = {
23857 (char *) "self", NULL
23858 };
23859
23860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23862 if (SWIG_arg_fail(1)) SWIG_fail;
23863 {
23864 PyThreadState* __tstate = wxPyBeginAllowThreads();
23865 result = (bool)(arg1)->Dispatch();
23866
23867 wxPyEndAllowThreads(__tstate);
23868 if (PyErr_Occurred()) SWIG_fail;
23869 }
23870 {
23871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23872 }
23873 return resultobj;
23874 fail:
23875 return NULL;
23876 }
23877
23878
23879 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23880 PyObject *resultobj;
23881 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23882 bool result;
23883 PyObject * obj0 = 0 ;
23884 char *kwnames[] = {
23885 (char *) "self", NULL
23886 };
23887
23888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23890 if (SWIG_arg_fail(1)) SWIG_fail;
23891 {
23892 PyThreadState* __tstate = wxPyBeginAllowThreads();
23893 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23894
23895 wxPyEndAllowThreads(__tstate);
23896 if (PyErr_Occurred()) SWIG_fail;
23897 }
23898 {
23899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23900 }
23901 return resultobj;
23902 fail:
23903 return NULL;
23904 }
23905
23906
23907 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23908 PyObject *resultobj;
23909 wxEventLoop *result;
23910 char *kwnames[] = {
23911 NULL
23912 };
23913
23914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23915 {
23916 PyThreadState* __tstate = wxPyBeginAllowThreads();
23917 result = (wxEventLoop *)wxEventLoop::GetActive();
23918
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj;
23931 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23932 PyObject * obj0 = 0 ;
23933 char *kwnames[] = {
23934 (char *) "loop", NULL
23935 };
23936
23937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23939 if (SWIG_arg_fail(1)) SWIG_fail;
23940 {
23941 PyThreadState* __tstate = wxPyBeginAllowThreads();
23942 wxEventLoop::SetActive(arg1);
23943
23944 wxPyEndAllowThreads(__tstate);
23945 if (PyErr_Occurred()) SWIG_fail;
23946 }
23947 Py_INCREF(Py_None); resultobj = Py_None;
23948 return resultobj;
23949 fail:
23950 return NULL;
23951 }
23952
23953
23954 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23955 PyObject *obj;
23956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23957 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23958 Py_INCREF(obj);
23959 return Py_BuildValue((char *)"");
23960 }
23961 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23962 PyObject *resultobj;
23963 int arg1 = (int) 0 ;
23964 int arg2 = (int) 0 ;
23965 int arg3 = (int) 0 ;
23966 wxAcceleratorEntry *result;
23967 PyObject * obj0 = 0 ;
23968 PyObject * obj1 = 0 ;
23969 PyObject * obj2 = 0 ;
23970 char *kwnames[] = {
23971 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23972 };
23973
23974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23975 if (obj0) {
23976 {
23977 arg1 = (int)(SWIG_As_int(obj0));
23978 if (SWIG_arg_fail(1)) SWIG_fail;
23979 }
23980 }
23981 if (obj1) {
23982 {
23983 arg2 = (int)(SWIG_As_int(obj1));
23984 if (SWIG_arg_fail(2)) SWIG_fail;
23985 }
23986 }
23987 if (obj2) {
23988 {
23989 arg3 = (int)(SWIG_As_int(obj2));
23990 if (SWIG_arg_fail(3)) SWIG_fail;
23991 }
23992 }
23993 {
23994 PyThreadState* __tstate = wxPyBeginAllowThreads();
23995 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23996
23997 wxPyEndAllowThreads(__tstate);
23998 if (PyErr_Occurred()) SWIG_fail;
23999 }
24000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24008 PyObject *resultobj;
24009 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24010 PyObject * obj0 = 0 ;
24011 char *kwnames[] = {
24012 (char *) "self", NULL
24013 };
24014
24015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24017 if (SWIG_arg_fail(1)) SWIG_fail;
24018 {
24019 PyThreadState* __tstate = wxPyBeginAllowThreads();
24020 delete arg1;
24021
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 Py_INCREF(Py_None); resultobj = Py_None;
24026 return resultobj;
24027 fail:
24028 return NULL;
24029 }
24030
24031
24032 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24033 PyObject *resultobj;
24034 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24035 int arg2 ;
24036 int arg3 ;
24037 int arg4 ;
24038 PyObject * obj0 = 0 ;
24039 PyObject * obj1 = 0 ;
24040 PyObject * obj2 = 0 ;
24041 PyObject * obj3 = 0 ;
24042 char *kwnames[] = {
24043 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24044 };
24045
24046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24048 if (SWIG_arg_fail(1)) SWIG_fail;
24049 {
24050 arg2 = (int)(SWIG_As_int(obj1));
24051 if (SWIG_arg_fail(2)) SWIG_fail;
24052 }
24053 {
24054 arg3 = (int)(SWIG_As_int(obj2));
24055 if (SWIG_arg_fail(3)) SWIG_fail;
24056 }
24057 {
24058 arg4 = (int)(SWIG_As_int(obj3));
24059 if (SWIG_arg_fail(4)) SWIG_fail;
24060 }
24061 {
24062 PyThreadState* __tstate = wxPyBeginAllowThreads();
24063 (arg1)->Set(arg2,arg3,arg4);
24064
24065 wxPyEndAllowThreads(__tstate);
24066 if (PyErr_Occurred()) SWIG_fail;
24067 }
24068 Py_INCREF(Py_None); resultobj = Py_None;
24069 return resultobj;
24070 fail:
24071 return NULL;
24072 }
24073
24074
24075 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24076 PyObject *resultobj;
24077 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24078 int result;
24079 PyObject * obj0 = 0 ;
24080 char *kwnames[] = {
24081 (char *) "self", NULL
24082 };
24083
24084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24086 if (SWIG_arg_fail(1)) SWIG_fail;
24087 {
24088 PyThreadState* __tstate = wxPyBeginAllowThreads();
24089 result = (int)(arg1)->GetFlags();
24090
24091 wxPyEndAllowThreads(__tstate);
24092 if (PyErr_Occurred()) SWIG_fail;
24093 }
24094 {
24095 resultobj = SWIG_From_int((int)(result));
24096 }
24097 return resultobj;
24098 fail:
24099 return NULL;
24100 }
24101
24102
24103 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24104 PyObject *resultobj;
24105 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24106 int result;
24107 PyObject * obj0 = 0 ;
24108 char *kwnames[] = {
24109 (char *) "self", NULL
24110 };
24111
24112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24114 if (SWIG_arg_fail(1)) SWIG_fail;
24115 {
24116 PyThreadState* __tstate = wxPyBeginAllowThreads();
24117 result = (int)(arg1)->GetKeyCode();
24118
24119 wxPyEndAllowThreads(__tstate);
24120 if (PyErr_Occurred()) SWIG_fail;
24121 }
24122 {
24123 resultobj = SWIG_From_int((int)(result));
24124 }
24125 return resultobj;
24126 fail:
24127 return NULL;
24128 }
24129
24130
24131 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24132 PyObject *resultobj;
24133 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24134 int result;
24135 PyObject * obj0 = 0 ;
24136 char *kwnames[] = {
24137 (char *) "self", NULL
24138 };
24139
24140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24142 if (SWIG_arg_fail(1)) SWIG_fail;
24143 {
24144 PyThreadState* __tstate = wxPyBeginAllowThreads();
24145 result = (int)(arg1)->GetCommand();
24146
24147 wxPyEndAllowThreads(__tstate);
24148 if (PyErr_Occurred()) SWIG_fail;
24149 }
24150 {
24151 resultobj = SWIG_From_int((int)(result));
24152 }
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24160 PyObject *obj;
24161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24162 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24163 Py_INCREF(obj);
24164 return Py_BuildValue((char *)"");
24165 }
24166 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24167 PyObject *resultobj;
24168 int arg1 ;
24169 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24170 wxAcceleratorTable *result;
24171 PyObject * obj0 = 0 ;
24172 char *kwnames[] = {
24173 (char *) "n", NULL
24174 };
24175
24176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24177 {
24178 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24179 if (arg2) arg1 = PyList_Size(obj0);
24180 else arg1 = 0;
24181 }
24182 {
24183 PyThreadState* __tstate = wxPyBeginAllowThreads();
24184 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24185
24186 wxPyEndAllowThreads(__tstate);
24187 if (PyErr_Occurred()) SWIG_fail;
24188 }
24189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24190 {
24191 delete [] arg2;
24192 }
24193 return resultobj;
24194 fail:
24195 {
24196 delete [] arg2;
24197 }
24198 return NULL;
24199 }
24200
24201
24202 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24203 PyObject *resultobj;
24204 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24205 PyObject * obj0 = 0 ;
24206 char *kwnames[] = {
24207 (char *) "self", NULL
24208 };
24209
24210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24212 if (SWIG_arg_fail(1)) SWIG_fail;
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 delete arg1;
24216
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 Py_INCREF(Py_None); resultobj = Py_None;
24221 return resultobj;
24222 fail:
24223 return NULL;
24224 }
24225
24226
24227 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj;
24229 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24230 bool result;
24231 PyObject * obj0 = 0 ;
24232 char *kwnames[] = {
24233 (char *) "self", NULL
24234 };
24235
24236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24238 if (SWIG_arg_fail(1)) SWIG_fail;
24239 {
24240 PyThreadState* __tstate = wxPyBeginAllowThreads();
24241 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24242
24243 wxPyEndAllowThreads(__tstate);
24244 if (PyErr_Occurred()) SWIG_fail;
24245 }
24246 {
24247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24248 }
24249 return resultobj;
24250 fail:
24251 return NULL;
24252 }
24253
24254
24255 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24256 PyObject *obj;
24257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24258 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24259 Py_INCREF(obj);
24260 return Py_BuildValue((char *)"");
24261 }
24262 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24263 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24264 return 1;
24265 }
24266
24267
24268 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24269 PyObject *pyobj;
24270
24271 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24272 return pyobj;
24273 }
24274
24275
24276 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24277 PyObject *resultobj;
24278 wxString *arg1 = 0 ;
24279 wxAcceleratorEntry *result;
24280 bool temp1 = false ;
24281 PyObject * obj0 = 0 ;
24282 char *kwnames[] = {
24283 (char *) "label", NULL
24284 };
24285
24286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24287 {
24288 arg1 = wxString_in_helper(obj0);
24289 if (arg1 == NULL) SWIG_fail;
24290 temp1 = true;
24291 }
24292 {
24293 PyThreadState* __tstate = wxPyBeginAllowThreads();
24294 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24295
24296 wxPyEndAllowThreads(__tstate);
24297 if (PyErr_Occurred()) SWIG_fail;
24298 }
24299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24300 {
24301 if (temp1)
24302 delete arg1;
24303 }
24304 return resultobj;
24305 fail:
24306 {
24307 if (temp1)
24308 delete arg1;
24309 }
24310 return NULL;
24311 }
24312
24313
24314 static int _wrap_PanelNameStr_set(PyObject *) {
24315 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24316 return 1;
24317 }
24318
24319
24320 static PyObject *_wrap_PanelNameStr_get(void) {
24321 PyObject *pyobj;
24322
24323 {
24324 #if wxUSE_UNICODE
24325 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24326 #else
24327 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24328 #endif
24329 }
24330 return pyobj;
24331 }
24332
24333
24334 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24335 PyObject *resultobj;
24336 wxVisualAttributes *result;
24337 char *kwnames[] = {
24338 NULL
24339 };
24340
24341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24342 {
24343 PyThreadState* __tstate = wxPyBeginAllowThreads();
24344 result = (wxVisualAttributes *)new_wxVisualAttributes();
24345
24346 wxPyEndAllowThreads(__tstate);
24347 if (PyErr_Occurred()) SWIG_fail;
24348 }
24349 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24350 return resultobj;
24351 fail:
24352 return NULL;
24353 }
24354
24355
24356 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24357 PyObject *resultobj;
24358 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24359 PyObject * obj0 = 0 ;
24360 char *kwnames[] = {
24361 (char *) "self", NULL
24362 };
24363
24364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24366 if (SWIG_arg_fail(1)) SWIG_fail;
24367 {
24368 PyThreadState* __tstate = wxPyBeginAllowThreads();
24369 delete_wxVisualAttributes(arg1);
24370
24371 wxPyEndAllowThreads(__tstate);
24372 if (PyErr_Occurred()) SWIG_fail;
24373 }
24374 Py_INCREF(Py_None); resultobj = Py_None;
24375 return resultobj;
24376 fail:
24377 return NULL;
24378 }
24379
24380
24381 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24382 PyObject *resultobj;
24383 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24384 wxFont *arg2 = (wxFont *) 0 ;
24385 PyObject * obj0 = 0 ;
24386 PyObject * obj1 = 0 ;
24387 char *kwnames[] = {
24388 (char *) "self",(char *) "font", NULL
24389 };
24390
24391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24393 if (SWIG_arg_fail(1)) SWIG_fail;
24394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24395 if (SWIG_arg_fail(2)) SWIG_fail;
24396 if (arg1) (arg1)->font = *arg2;
24397
24398 Py_INCREF(Py_None); resultobj = Py_None;
24399 return resultobj;
24400 fail:
24401 return NULL;
24402 }
24403
24404
24405 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24406 PyObject *resultobj;
24407 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24408 wxFont *result;
24409 PyObject * obj0 = 0 ;
24410 char *kwnames[] = {
24411 (char *) "self", NULL
24412 };
24413
24414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24416 if (SWIG_arg_fail(1)) SWIG_fail;
24417 result = (wxFont *)& ((arg1)->font);
24418
24419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24420 return resultobj;
24421 fail:
24422 return NULL;
24423 }
24424
24425
24426 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24427 PyObject *resultobj;
24428 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24429 wxColour *arg2 = (wxColour *) 0 ;
24430 PyObject * obj0 = 0 ;
24431 PyObject * obj1 = 0 ;
24432 char *kwnames[] = {
24433 (char *) "self",(char *) "colFg", NULL
24434 };
24435
24436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24438 if (SWIG_arg_fail(1)) SWIG_fail;
24439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24440 if (SWIG_arg_fail(2)) SWIG_fail;
24441 if (arg1) (arg1)->colFg = *arg2;
24442
24443 Py_INCREF(Py_None); resultobj = Py_None;
24444 return resultobj;
24445 fail:
24446 return NULL;
24447 }
24448
24449
24450 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24451 PyObject *resultobj;
24452 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24453 wxColour *result;
24454 PyObject * obj0 = 0 ;
24455 char *kwnames[] = {
24456 (char *) "self", NULL
24457 };
24458
24459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24461 if (SWIG_arg_fail(1)) SWIG_fail;
24462 result = (wxColour *)& ((arg1)->colFg);
24463
24464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24472 PyObject *resultobj;
24473 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24474 wxColour *arg2 = (wxColour *) 0 ;
24475 PyObject * obj0 = 0 ;
24476 PyObject * obj1 = 0 ;
24477 char *kwnames[] = {
24478 (char *) "self",(char *) "colBg", NULL
24479 };
24480
24481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24483 if (SWIG_arg_fail(1)) SWIG_fail;
24484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24485 if (SWIG_arg_fail(2)) SWIG_fail;
24486 if (arg1) (arg1)->colBg = *arg2;
24487
24488 Py_INCREF(Py_None); resultobj = Py_None;
24489 return resultobj;
24490 fail:
24491 return NULL;
24492 }
24493
24494
24495 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24496 PyObject *resultobj;
24497 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24498 wxColour *result;
24499 PyObject * obj0 = 0 ;
24500 char *kwnames[] = {
24501 (char *) "self", NULL
24502 };
24503
24504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24506 if (SWIG_arg_fail(1)) SWIG_fail;
24507 result = (wxColour *)& ((arg1)->colBg);
24508
24509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24510 return resultobj;
24511 fail:
24512 return NULL;
24513 }
24514
24515
24516 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24517 PyObject *obj;
24518 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24519 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24520 Py_INCREF(obj);
24521 return Py_BuildValue((char *)"");
24522 }
24523 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24524 PyObject *resultobj;
24525 wxWindow *arg1 = (wxWindow *) 0 ;
24526 int arg2 = (int) (int)-1 ;
24527 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24528 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24529 wxSize const &arg4_defvalue = wxDefaultSize ;
24530 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24531 long arg5 = (long) 0 ;
24532 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24533 wxString *arg6 = (wxString *) &arg6_defvalue ;
24534 wxWindow *result;
24535 wxPoint temp3 ;
24536 wxSize temp4 ;
24537 bool temp6 = false ;
24538 PyObject * obj0 = 0 ;
24539 PyObject * obj1 = 0 ;
24540 PyObject * obj2 = 0 ;
24541 PyObject * obj3 = 0 ;
24542 PyObject * obj4 = 0 ;
24543 PyObject * obj5 = 0 ;
24544 char *kwnames[] = {
24545 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24546 };
24547
24548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24550 if (SWIG_arg_fail(1)) SWIG_fail;
24551 if (obj1) {
24552 {
24553 arg2 = (int const)(SWIG_As_int(obj1));
24554 if (SWIG_arg_fail(2)) SWIG_fail;
24555 }
24556 }
24557 if (obj2) {
24558 {
24559 arg3 = &temp3;
24560 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24561 }
24562 }
24563 if (obj3) {
24564 {
24565 arg4 = &temp4;
24566 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24567 }
24568 }
24569 if (obj4) {
24570 {
24571 arg5 = (long)(SWIG_As_long(obj4));
24572 if (SWIG_arg_fail(5)) SWIG_fail;
24573 }
24574 }
24575 if (obj5) {
24576 {
24577 arg6 = wxString_in_helper(obj5);
24578 if (arg6 == NULL) SWIG_fail;
24579 temp6 = true;
24580 }
24581 }
24582 {
24583 if (!wxPyCheckForApp()) SWIG_fail;
24584 PyThreadState* __tstate = wxPyBeginAllowThreads();
24585 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24586
24587 wxPyEndAllowThreads(__tstate);
24588 if (PyErr_Occurred()) SWIG_fail;
24589 }
24590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24591 {
24592 if (temp6)
24593 delete arg6;
24594 }
24595 return resultobj;
24596 fail:
24597 {
24598 if (temp6)
24599 delete arg6;
24600 }
24601 return NULL;
24602 }
24603
24604
24605 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24606 PyObject *resultobj;
24607 wxWindow *result;
24608 char *kwnames[] = {
24609 NULL
24610 };
24611
24612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24613 {
24614 if (!wxPyCheckForApp()) SWIG_fail;
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 result = (wxWindow *)new wxWindow();
24617
24618 wxPyEndAllowThreads(__tstate);
24619 if (PyErr_Occurred()) SWIG_fail;
24620 }
24621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24622 return resultobj;
24623 fail:
24624 return NULL;
24625 }
24626
24627
24628 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24629 PyObject *resultobj;
24630 wxWindow *arg1 = (wxWindow *) 0 ;
24631 wxWindow *arg2 = (wxWindow *) 0 ;
24632 int arg3 = (int) (int)-1 ;
24633 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24634 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24635 wxSize const &arg5_defvalue = wxDefaultSize ;
24636 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24637 long arg6 = (long) 0 ;
24638 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24639 wxString *arg7 = (wxString *) &arg7_defvalue ;
24640 bool result;
24641 wxPoint temp4 ;
24642 wxSize temp5 ;
24643 bool temp7 = false ;
24644 PyObject * obj0 = 0 ;
24645 PyObject * obj1 = 0 ;
24646 PyObject * obj2 = 0 ;
24647 PyObject * obj3 = 0 ;
24648 PyObject * obj4 = 0 ;
24649 PyObject * obj5 = 0 ;
24650 PyObject * obj6 = 0 ;
24651 char *kwnames[] = {
24652 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24653 };
24654
24655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24657 if (SWIG_arg_fail(1)) SWIG_fail;
24658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24659 if (SWIG_arg_fail(2)) SWIG_fail;
24660 if (obj2) {
24661 {
24662 arg3 = (int const)(SWIG_As_int(obj2));
24663 if (SWIG_arg_fail(3)) SWIG_fail;
24664 }
24665 }
24666 if (obj3) {
24667 {
24668 arg4 = &temp4;
24669 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24670 }
24671 }
24672 if (obj4) {
24673 {
24674 arg5 = &temp5;
24675 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24676 }
24677 }
24678 if (obj5) {
24679 {
24680 arg6 = (long)(SWIG_As_long(obj5));
24681 if (SWIG_arg_fail(6)) SWIG_fail;
24682 }
24683 }
24684 if (obj6) {
24685 {
24686 arg7 = wxString_in_helper(obj6);
24687 if (arg7 == NULL) SWIG_fail;
24688 temp7 = true;
24689 }
24690 }
24691 {
24692 PyThreadState* __tstate = wxPyBeginAllowThreads();
24693 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24694
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 {
24699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24700 }
24701 {
24702 if (temp7)
24703 delete arg7;
24704 }
24705 return resultobj;
24706 fail:
24707 {
24708 if (temp7)
24709 delete arg7;
24710 }
24711 return NULL;
24712 }
24713
24714
24715 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24716 PyObject *resultobj;
24717 wxWindow *arg1 = (wxWindow *) 0 ;
24718 bool arg2 = (bool) false ;
24719 bool result;
24720 PyObject * obj0 = 0 ;
24721 PyObject * obj1 = 0 ;
24722 char *kwnames[] = {
24723 (char *) "self",(char *) "force", NULL
24724 };
24725
24726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24728 if (SWIG_arg_fail(1)) SWIG_fail;
24729 if (obj1) {
24730 {
24731 arg2 = (bool)(SWIG_As_bool(obj1));
24732 if (SWIG_arg_fail(2)) SWIG_fail;
24733 }
24734 }
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (bool)(arg1)->Close(arg2);
24738
24739 wxPyEndAllowThreads(__tstate);
24740 if (PyErr_Occurred()) SWIG_fail;
24741 }
24742 {
24743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24744 }
24745 return resultobj;
24746 fail:
24747 return NULL;
24748 }
24749
24750
24751 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24752 PyObject *resultobj;
24753 wxWindow *arg1 = (wxWindow *) 0 ;
24754 bool result;
24755 PyObject * obj0 = 0 ;
24756 char *kwnames[] = {
24757 (char *) "self", NULL
24758 };
24759
24760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24762 if (SWIG_arg_fail(1)) SWIG_fail;
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (bool)(arg1)->Destroy();
24766
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 {
24771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24772 }
24773 return resultobj;
24774 fail:
24775 return NULL;
24776 }
24777
24778
24779 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24780 PyObject *resultobj;
24781 wxWindow *arg1 = (wxWindow *) 0 ;
24782 bool result;
24783 PyObject * obj0 = 0 ;
24784 char *kwnames[] = {
24785 (char *) "self", NULL
24786 };
24787
24788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24790 if (SWIG_arg_fail(1)) SWIG_fail;
24791 {
24792 PyThreadState* __tstate = wxPyBeginAllowThreads();
24793 result = (bool)(arg1)->DestroyChildren();
24794
24795 wxPyEndAllowThreads(__tstate);
24796 if (PyErr_Occurred()) SWIG_fail;
24797 }
24798 {
24799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24800 }
24801 return resultobj;
24802 fail:
24803 return NULL;
24804 }
24805
24806
24807 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24808 PyObject *resultobj;
24809 wxWindow *arg1 = (wxWindow *) 0 ;
24810 bool result;
24811 PyObject * obj0 = 0 ;
24812 char *kwnames[] = {
24813 (char *) "self", NULL
24814 };
24815
24816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24818 if (SWIG_arg_fail(1)) SWIG_fail;
24819 {
24820 PyThreadState* __tstate = wxPyBeginAllowThreads();
24821 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24822
24823 wxPyEndAllowThreads(__tstate);
24824 if (PyErr_Occurred()) SWIG_fail;
24825 }
24826 {
24827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24828 }
24829 return resultobj;
24830 fail:
24831 return NULL;
24832 }
24833
24834
24835 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24836 PyObject *resultobj;
24837 wxWindow *arg1 = (wxWindow *) 0 ;
24838 wxString *arg2 = 0 ;
24839 bool temp2 = false ;
24840 PyObject * obj0 = 0 ;
24841 PyObject * obj1 = 0 ;
24842 char *kwnames[] = {
24843 (char *) "self",(char *) "title", NULL
24844 };
24845
24846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24848 if (SWIG_arg_fail(1)) SWIG_fail;
24849 {
24850 arg2 = wxString_in_helper(obj1);
24851 if (arg2 == NULL) SWIG_fail;
24852 temp2 = true;
24853 }
24854 {
24855 PyThreadState* __tstate = wxPyBeginAllowThreads();
24856 (arg1)->SetTitle((wxString const &)*arg2);
24857
24858 wxPyEndAllowThreads(__tstate);
24859 if (PyErr_Occurred()) SWIG_fail;
24860 }
24861 Py_INCREF(Py_None); resultobj = Py_None;
24862 {
24863 if (temp2)
24864 delete arg2;
24865 }
24866 return resultobj;
24867 fail:
24868 {
24869 if (temp2)
24870 delete arg2;
24871 }
24872 return NULL;
24873 }
24874
24875
24876 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24877 PyObject *resultobj;
24878 wxWindow *arg1 = (wxWindow *) 0 ;
24879 wxString result;
24880 PyObject * obj0 = 0 ;
24881 char *kwnames[] = {
24882 (char *) "self", NULL
24883 };
24884
24885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24887 if (SWIG_arg_fail(1)) SWIG_fail;
24888 {
24889 PyThreadState* __tstate = wxPyBeginAllowThreads();
24890 result = ((wxWindow const *)arg1)->GetTitle();
24891
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 {
24896 #if wxUSE_UNICODE
24897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24898 #else
24899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24900 #endif
24901 }
24902 return resultobj;
24903 fail:
24904 return NULL;
24905 }
24906
24907
24908 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24909 PyObject *resultobj;
24910 wxWindow *arg1 = (wxWindow *) 0 ;
24911 wxString *arg2 = 0 ;
24912 bool temp2 = false ;
24913 PyObject * obj0 = 0 ;
24914 PyObject * obj1 = 0 ;
24915 char *kwnames[] = {
24916 (char *) "self",(char *) "label", NULL
24917 };
24918
24919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24921 if (SWIG_arg_fail(1)) SWIG_fail;
24922 {
24923 arg2 = wxString_in_helper(obj1);
24924 if (arg2 == NULL) SWIG_fail;
24925 temp2 = true;
24926 }
24927 {
24928 PyThreadState* __tstate = wxPyBeginAllowThreads();
24929 (arg1)->SetLabel((wxString const &)*arg2);
24930
24931 wxPyEndAllowThreads(__tstate);
24932 if (PyErr_Occurred()) SWIG_fail;
24933 }
24934 Py_INCREF(Py_None); resultobj = Py_None;
24935 {
24936 if (temp2)
24937 delete arg2;
24938 }
24939 return resultobj;
24940 fail:
24941 {
24942 if (temp2)
24943 delete arg2;
24944 }
24945 return NULL;
24946 }
24947
24948
24949 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24950 PyObject *resultobj;
24951 wxWindow *arg1 = (wxWindow *) 0 ;
24952 wxString result;
24953 PyObject * obj0 = 0 ;
24954 char *kwnames[] = {
24955 (char *) "self", NULL
24956 };
24957
24958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24960 if (SWIG_arg_fail(1)) SWIG_fail;
24961 {
24962 PyThreadState* __tstate = wxPyBeginAllowThreads();
24963 result = ((wxWindow const *)arg1)->GetLabel();
24964
24965 wxPyEndAllowThreads(__tstate);
24966 if (PyErr_Occurred()) SWIG_fail;
24967 }
24968 {
24969 #if wxUSE_UNICODE
24970 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24971 #else
24972 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24973 #endif
24974 }
24975 return resultobj;
24976 fail:
24977 return NULL;
24978 }
24979
24980
24981 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24982 PyObject *resultobj;
24983 wxWindow *arg1 = (wxWindow *) 0 ;
24984 wxString *arg2 = 0 ;
24985 bool temp2 = false ;
24986 PyObject * obj0 = 0 ;
24987 PyObject * obj1 = 0 ;
24988 char *kwnames[] = {
24989 (char *) "self",(char *) "name", NULL
24990 };
24991
24992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24994 if (SWIG_arg_fail(1)) SWIG_fail;
24995 {
24996 arg2 = wxString_in_helper(obj1);
24997 if (arg2 == NULL) SWIG_fail;
24998 temp2 = true;
24999 }
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 (arg1)->SetName((wxString const &)*arg2);
25003
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 Py_INCREF(Py_None); resultobj = Py_None;
25008 {
25009 if (temp2)
25010 delete arg2;
25011 }
25012 return resultobj;
25013 fail:
25014 {
25015 if (temp2)
25016 delete arg2;
25017 }
25018 return NULL;
25019 }
25020
25021
25022 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25023 PyObject *resultobj;
25024 wxWindow *arg1 = (wxWindow *) 0 ;
25025 wxString result;
25026 PyObject * obj0 = 0 ;
25027 char *kwnames[] = {
25028 (char *) "self", NULL
25029 };
25030
25031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25033 if (SWIG_arg_fail(1)) SWIG_fail;
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 result = ((wxWindow const *)arg1)->GetName();
25037
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 {
25042 #if wxUSE_UNICODE
25043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25044 #else
25045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25046 #endif
25047 }
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25055 PyObject *resultobj;
25056 wxWindow *arg1 = (wxWindow *) 0 ;
25057 wxWindowVariant arg2 ;
25058 PyObject * obj0 = 0 ;
25059 PyObject * obj1 = 0 ;
25060 char *kwnames[] = {
25061 (char *) "self",(char *) "variant", NULL
25062 };
25063
25064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25066 if (SWIG_arg_fail(1)) SWIG_fail;
25067 {
25068 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25069 if (SWIG_arg_fail(2)) SWIG_fail;
25070 }
25071 {
25072 PyThreadState* __tstate = wxPyBeginAllowThreads();
25073 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25074
25075 wxPyEndAllowThreads(__tstate);
25076 if (PyErr_Occurred()) SWIG_fail;
25077 }
25078 Py_INCREF(Py_None); resultobj = Py_None;
25079 return resultobj;
25080 fail:
25081 return NULL;
25082 }
25083
25084
25085 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25086 PyObject *resultobj;
25087 wxWindow *arg1 = (wxWindow *) 0 ;
25088 wxWindowVariant result;
25089 PyObject * obj0 = 0 ;
25090 char *kwnames[] = {
25091 (char *) "self", NULL
25092 };
25093
25094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25096 if (SWIG_arg_fail(1)) SWIG_fail;
25097 {
25098 PyThreadState* __tstate = wxPyBeginAllowThreads();
25099 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25100
25101 wxPyEndAllowThreads(__tstate);
25102 if (PyErr_Occurred()) SWIG_fail;
25103 }
25104 resultobj = SWIG_From_int((result));
25105 return resultobj;
25106 fail:
25107 return NULL;
25108 }
25109
25110
25111 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25112 PyObject *resultobj;
25113 wxWindow *arg1 = (wxWindow *) 0 ;
25114 int arg2 ;
25115 PyObject * obj0 = 0 ;
25116 PyObject * obj1 = 0 ;
25117 char *kwnames[] = {
25118 (char *) "self",(char *) "winid", NULL
25119 };
25120
25121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25123 if (SWIG_arg_fail(1)) SWIG_fail;
25124 {
25125 arg2 = (int)(SWIG_As_int(obj1));
25126 if (SWIG_arg_fail(2)) SWIG_fail;
25127 }
25128 {
25129 PyThreadState* __tstate = wxPyBeginAllowThreads();
25130 (arg1)->SetId(arg2);
25131
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 Py_INCREF(Py_None); resultobj = Py_None;
25136 return resultobj;
25137 fail:
25138 return NULL;
25139 }
25140
25141
25142 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25143 PyObject *resultobj;
25144 wxWindow *arg1 = (wxWindow *) 0 ;
25145 int result;
25146 PyObject * obj0 = 0 ;
25147 char *kwnames[] = {
25148 (char *) "self", NULL
25149 };
25150
25151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25153 if (SWIG_arg_fail(1)) SWIG_fail;
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (int)((wxWindow const *)arg1)->GetId();
25157
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 {
25162 resultobj = SWIG_From_int((int)(result));
25163 }
25164 return resultobj;
25165 fail:
25166 return NULL;
25167 }
25168
25169
25170 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25171 PyObject *resultobj;
25172 int result;
25173 char *kwnames[] = {
25174 NULL
25175 };
25176
25177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25178 {
25179 PyThreadState* __tstate = wxPyBeginAllowThreads();
25180 result = (int)wxWindow::NewControlId();
25181
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 {
25186 resultobj = SWIG_From_int((int)(result));
25187 }
25188 return resultobj;
25189 fail:
25190 return NULL;
25191 }
25192
25193
25194 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25195 PyObject *resultobj;
25196 int arg1 ;
25197 int result;
25198 PyObject * obj0 = 0 ;
25199 char *kwnames[] = {
25200 (char *) "winid", NULL
25201 };
25202
25203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25204 {
25205 arg1 = (int)(SWIG_As_int(obj0));
25206 if (SWIG_arg_fail(1)) SWIG_fail;
25207 }
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 result = (int)wxWindow::NextControlId(arg1);
25211
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 {
25216 resultobj = SWIG_From_int((int)(result));
25217 }
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj;
25226 int arg1 ;
25227 int result;
25228 PyObject * obj0 = 0 ;
25229 char *kwnames[] = {
25230 (char *) "winid", NULL
25231 };
25232
25233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25234 {
25235 arg1 = (int)(SWIG_As_int(obj0));
25236 if (SWIG_arg_fail(1)) SWIG_fail;
25237 }
25238 {
25239 PyThreadState* __tstate = wxPyBeginAllowThreads();
25240 result = (int)wxWindow::PrevControlId(arg1);
25241
25242 wxPyEndAllowThreads(__tstate);
25243 if (PyErr_Occurred()) SWIG_fail;
25244 }
25245 {
25246 resultobj = SWIG_From_int((int)(result));
25247 }
25248 return resultobj;
25249 fail:
25250 return NULL;
25251 }
25252
25253
25254 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25255 PyObject *resultobj;
25256 wxWindow *arg1 = (wxWindow *) 0 ;
25257 wxSize *arg2 = 0 ;
25258 wxSize temp2 ;
25259 PyObject * obj0 = 0 ;
25260 PyObject * obj1 = 0 ;
25261 char *kwnames[] = {
25262 (char *) "self",(char *) "size", NULL
25263 };
25264
25265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25267 if (SWIG_arg_fail(1)) SWIG_fail;
25268 {
25269 arg2 = &temp2;
25270 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25271 }
25272 {
25273 PyThreadState* __tstate = wxPyBeginAllowThreads();
25274 (arg1)->SetSize((wxSize const &)*arg2);
25275
25276 wxPyEndAllowThreads(__tstate);
25277 if (PyErr_Occurred()) SWIG_fail;
25278 }
25279 Py_INCREF(Py_None); resultobj = Py_None;
25280 return resultobj;
25281 fail:
25282 return NULL;
25283 }
25284
25285
25286 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25287 PyObject *resultobj;
25288 wxWindow *arg1 = (wxWindow *) 0 ;
25289 int arg2 ;
25290 int arg3 ;
25291 int arg4 ;
25292 int arg5 ;
25293 int arg6 = (int) wxSIZE_AUTO ;
25294 PyObject * obj0 = 0 ;
25295 PyObject * obj1 = 0 ;
25296 PyObject * obj2 = 0 ;
25297 PyObject * obj3 = 0 ;
25298 PyObject * obj4 = 0 ;
25299 PyObject * obj5 = 0 ;
25300 char *kwnames[] = {
25301 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25302 };
25303
25304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25306 if (SWIG_arg_fail(1)) SWIG_fail;
25307 {
25308 arg2 = (int)(SWIG_As_int(obj1));
25309 if (SWIG_arg_fail(2)) SWIG_fail;
25310 }
25311 {
25312 arg3 = (int)(SWIG_As_int(obj2));
25313 if (SWIG_arg_fail(3)) SWIG_fail;
25314 }
25315 {
25316 arg4 = (int)(SWIG_As_int(obj3));
25317 if (SWIG_arg_fail(4)) SWIG_fail;
25318 }
25319 {
25320 arg5 = (int)(SWIG_As_int(obj4));
25321 if (SWIG_arg_fail(5)) SWIG_fail;
25322 }
25323 if (obj5) {
25324 {
25325 arg6 = (int)(SWIG_As_int(obj5));
25326 if (SWIG_arg_fail(6)) SWIG_fail;
25327 }
25328 }
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25332
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 Py_INCREF(Py_None); resultobj = Py_None;
25337 return resultobj;
25338 fail:
25339 return NULL;
25340 }
25341
25342
25343 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25344 PyObject *resultobj;
25345 wxWindow *arg1 = (wxWindow *) 0 ;
25346 wxRect *arg2 = 0 ;
25347 int arg3 = (int) wxSIZE_AUTO ;
25348 wxRect temp2 ;
25349 PyObject * obj0 = 0 ;
25350 PyObject * obj1 = 0 ;
25351 PyObject * obj2 = 0 ;
25352 char *kwnames[] = {
25353 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25354 };
25355
25356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25358 if (SWIG_arg_fail(1)) SWIG_fail;
25359 {
25360 arg2 = &temp2;
25361 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25362 }
25363 if (obj2) {
25364 {
25365 arg3 = (int)(SWIG_As_int(obj2));
25366 if (SWIG_arg_fail(3)) SWIG_fail;
25367 }
25368 }
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25372
25373 wxPyEndAllowThreads(__tstate);
25374 if (PyErr_Occurred()) SWIG_fail;
25375 }
25376 Py_INCREF(Py_None); resultobj = Py_None;
25377 return resultobj;
25378 fail:
25379 return NULL;
25380 }
25381
25382
25383 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25384 PyObject *resultobj;
25385 wxWindow *arg1 = (wxWindow *) 0 ;
25386 int arg2 ;
25387 int arg3 ;
25388 PyObject * obj0 = 0 ;
25389 PyObject * obj1 = 0 ;
25390 PyObject * obj2 = 0 ;
25391 char *kwnames[] = {
25392 (char *) "self",(char *) "width",(char *) "height", NULL
25393 };
25394
25395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25397 if (SWIG_arg_fail(1)) SWIG_fail;
25398 {
25399 arg2 = (int)(SWIG_As_int(obj1));
25400 if (SWIG_arg_fail(2)) SWIG_fail;
25401 }
25402 {
25403 arg3 = (int)(SWIG_As_int(obj2));
25404 if (SWIG_arg_fail(3)) SWIG_fail;
25405 }
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 (arg1)->SetSize(arg2,arg3);
25409
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 Py_INCREF(Py_None); resultobj = Py_None;
25414 return resultobj;
25415 fail:
25416 return NULL;
25417 }
25418
25419
25420 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25421 PyObject *resultobj;
25422 wxWindow *arg1 = (wxWindow *) 0 ;
25423 wxPoint *arg2 = 0 ;
25424 int arg3 = (int) wxSIZE_USE_EXISTING ;
25425 wxPoint temp2 ;
25426 PyObject * obj0 = 0 ;
25427 PyObject * obj1 = 0 ;
25428 PyObject * obj2 = 0 ;
25429 char *kwnames[] = {
25430 (char *) "self",(char *) "pt",(char *) "flags", NULL
25431 };
25432
25433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25435 if (SWIG_arg_fail(1)) SWIG_fail;
25436 {
25437 arg2 = &temp2;
25438 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25439 }
25440 if (obj2) {
25441 {
25442 arg3 = (int)(SWIG_As_int(obj2));
25443 if (SWIG_arg_fail(3)) SWIG_fail;
25444 }
25445 }
25446 {
25447 PyThreadState* __tstate = wxPyBeginAllowThreads();
25448 (arg1)->Move((wxPoint const &)*arg2,arg3);
25449
25450 wxPyEndAllowThreads(__tstate);
25451 if (PyErr_Occurred()) SWIG_fail;
25452 }
25453 Py_INCREF(Py_None); resultobj = Py_None;
25454 return resultobj;
25455 fail:
25456 return NULL;
25457 }
25458
25459
25460 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25461 PyObject *resultobj;
25462 wxWindow *arg1 = (wxWindow *) 0 ;
25463 int arg2 ;
25464 int arg3 ;
25465 int arg4 = (int) wxSIZE_USE_EXISTING ;
25466 PyObject * obj0 = 0 ;
25467 PyObject * obj1 = 0 ;
25468 PyObject * obj2 = 0 ;
25469 PyObject * obj3 = 0 ;
25470 char *kwnames[] = {
25471 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25472 };
25473
25474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25476 if (SWIG_arg_fail(1)) SWIG_fail;
25477 {
25478 arg2 = (int)(SWIG_As_int(obj1));
25479 if (SWIG_arg_fail(2)) SWIG_fail;
25480 }
25481 {
25482 arg3 = (int)(SWIG_As_int(obj2));
25483 if (SWIG_arg_fail(3)) SWIG_fail;
25484 }
25485 if (obj3) {
25486 {
25487 arg4 = (int)(SWIG_As_int(obj3));
25488 if (SWIG_arg_fail(4)) SWIG_fail;
25489 }
25490 }
25491 {
25492 PyThreadState* __tstate = wxPyBeginAllowThreads();
25493 (arg1)->Move(arg2,arg3,arg4);
25494
25495 wxPyEndAllowThreads(__tstate);
25496 if (PyErr_Occurred()) SWIG_fail;
25497 }
25498 Py_INCREF(Py_None); resultobj = Py_None;
25499 return resultobj;
25500 fail:
25501 return NULL;
25502 }
25503
25504
25505 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25506 PyObject *resultobj;
25507 wxWindow *arg1 = (wxWindow *) 0 ;
25508 wxSize const &arg2_defvalue = wxDefaultSize ;
25509 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25510 wxSize temp2 ;
25511 PyObject * obj0 = 0 ;
25512 PyObject * obj1 = 0 ;
25513 char *kwnames[] = {
25514 (char *) "self",(char *) "size", NULL
25515 };
25516
25517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25519 if (SWIG_arg_fail(1)) SWIG_fail;
25520 if (obj1) {
25521 {
25522 arg2 = &temp2;
25523 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25524 }
25525 }
25526 {
25527 PyThreadState* __tstate = wxPyBeginAllowThreads();
25528 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25529
25530 wxPyEndAllowThreads(__tstate);
25531 if (PyErr_Occurred()) SWIG_fail;
25532 }
25533 Py_INCREF(Py_None); resultobj = Py_None;
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25541 PyObject *resultobj;
25542 wxWindow *arg1 = (wxWindow *) 0 ;
25543 PyObject * obj0 = 0 ;
25544 char *kwnames[] = {
25545 (char *) "self", NULL
25546 };
25547
25548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25550 if (SWIG_arg_fail(1)) SWIG_fail;
25551 {
25552 PyThreadState* __tstate = wxPyBeginAllowThreads();
25553 (arg1)->Raise();
25554
25555 wxPyEndAllowThreads(__tstate);
25556 if (PyErr_Occurred()) SWIG_fail;
25557 }
25558 Py_INCREF(Py_None); resultobj = Py_None;
25559 return resultobj;
25560 fail:
25561 return NULL;
25562 }
25563
25564
25565 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25566 PyObject *resultobj;
25567 wxWindow *arg1 = (wxWindow *) 0 ;
25568 PyObject * obj0 = 0 ;
25569 char *kwnames[] = {
25570 (char *) "self", NULL
25571 };
25572
25573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25575 if (SWIG_arg_fail(1)) SWIG_fail;
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 (arg1)->Lower();
25579
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 Py_INCREF(Py_None); resultobj = Py_None;
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj;
25592 wxWindow *arg1 = (wxWindow *) 0 ;
25593 wxSize *arg2 = 0 ;
25594 wxSize temp2 ;
25595 PyObject * obj0 = 0 ;
25596 PyObject * obj1 = 0 ;
25597 char *kwnames[] = {
25598 (char *) "self",(char *) "size", NULL
25599 };
25600
25601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25603 if (SWIG_arg_fail(1)) SWIG_fail;
25604 {
25605 arg2 = &temp2;
25606 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25607 }
25608 {
25609 PyThreadState* __tstate = wxPyBeginAllowThreads();
25610 (arg1)->SetClientSize((wxSize const &)*arg2);
25611
25612 wxPyEndAllowThreads(__tstate);
25613 if (PyErr_Occurred()) SWIG_fail;
25614 }
25615 Py_INCREF(Py_None); resultobj = Py_None;
25616 return resultobj;
25617 fail:
25618 return NULL;
25619 }
25620
25621
25622 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25623 PyObject *resultobj;
25624 wxWindow *arg1 = (wxWindow *) 0 ;
25625 int arg2 ;
25626 int arg3 ;
25627 PyObject * obj0 = 0 ;
25628 PyObject * obj1 = 0 ;
25629 PyObject * obj2 = 0 ;
25630 char *kwnames[] = {
25631 (char *) "self",(char *) "width",(char *) "height", NULL
25632 };
25633
25634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25636 if (SWIG_arg_fail(1)) SWIG_fail;
25637 {
25638 arg2 = (int)(SWIG_As_int(obj1));
25639 if (SWIG_arg_fail(2)) SWIG_fail;
25640 }
25641 {
25642 arg3 = (int)(SWIG_As_int(obj2));
25643 if (SWIG_arg_fail(3)) SWIG_fail;
25644 }
25645 {
25646 PyThreadState* __tstate = wxPyBeginAllowThreads();
25647 (arg1)->SetClientSize(arg2,arg3);
25648
25649 wxPyEndAllowThreads(__tstate);
25650 if (PyErr_Occurred()) SWIG_fail;
25651 }
25652 Py_INCREF(Py_None); resultobj = Py_None;
25653 return resultobj;
25654 fail:
25655 return NULL;
25656 }
25657
25658
25659 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25660 PyObject *resultobj;
25661 wxWindow *arg1 = (wxWindow *) 0 ;
25662 wxRect *arg2 = 0 ;
25663 wxRect temp2 ;
25664 PyObject * obj0 = 0 ;
25665 PyObject * obj1 = 0 ;
25666 char *kwnames[] = {
25667 (char *) "self",(char *) "rect", NULL
25668 };
25669
25670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25672 if (SWIG_arg_fail(1)) SWIG_fail;
25673 {
25674 arg2 = &temp2;
25675 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25676 }
25677 {
25678 PyThreadState* __tstate = wxPyBeginAllowThreads();
25679 (arg1)->SetClientSize((wxRect const &)*arg2);
25680
25681 wxPyEndAllowThreads(__tstate);
25682 if (PyErr_Occurred()) SWIG_fail;
25683 }
25684 Py_INCREF(Py_None); resultobj = Py_None;
25685 return resultobj;
25686 fail:
25687 return NULL;
25688 }
25689
25690
25691 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25692 PyObject *resultobj;
25693 wxWindow *arg1 = (wxWindow *) 0 ;
25694 wxPoint result;
25695 PyObject * obj0 = 0 ;
25696 char *kwnames[] = {
25697 (char *) "self", NULL
25698 };
25699
25700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25702 if (SWIG_arg_fail(1)) SWIG_fail;
25703 {
25704 PyThreadState* __tstate = wxPyBeginAllowThreads();
25705 result = (arg1)->GetPosition();
25706
25707 wxPyEndAllowThreads(__tstate);
25708 if (PyErr_Occurred()) SWIG_fail;
25709 }
25710 {
25711 wxPoint * resultptr;
25712 resultptr = new wxPoint((wxPoint &)(result));
25713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25714 }
25715 return resultobj;
25716 fail:
25717 return NULL;
25718 }
25719
25720
25721 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25722 PyObject *resultobj;
25723 wxWindow *arg1 = (wxWindow *) 0 ;
25724 int *arg2 = (int *) 0 ;
25725 int *arg3 = (int *) 0 ;
25726 int temp2 ;
25727 int res2 = 0 ;
25728 int temp3 ;
25729 int res3 = 0 ;
25730 PyObject * obj0 = 0 ;
25731 char *kwnames[] = {
25732 (char *) "self", NULL
25733 };
25734
25735 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25736 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25739 if (SWIG_arg_fail(1)) SWIG_fail;
25740 {
25741 PyThreadState* __tstate = wxPyBeginAllowThreads();
25742 (arg1)->GetPosition(arg2,arg3);
25743
25744 wxPyEndAllowThreads(__tstate);
25745 if (PyErr_Occurred()) SWIG_fail;
25746 }
25747 Py_INCREF(Py_None); resultobj = Py_None;
25748 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25749 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25750 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25751 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25752 return resultobj;
25753 fail:
25754 return NULL;
25755 }
25756
25757
25758 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25759 PyObject *resultobj;
25760 wxWindow *arg1 = (wxWindow *) 0 ;
25761 wxSize result;
25762 PyObject * obj0 = 0 ;
25763 char *kwnames[] = {
25764 (char *) "self", NULL
25765 };
25766
25767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25769 if (SWIG_arg_fail(1)) SWIG_fail;
25770 {
25771 PyThreadState* __tstate = wxPyBeginAllowThreads();
25772 result = ((wxWindow const *)arg1)->GetSize();
25773
25774 wxPyEndAllowThreads(__tstate);
25775 if (PyErr_Occurred()) SWIG_fail;
25776 }
25777 {
25778 wxSize * resultptr;
25779 resultptr = new wxSize((wxSize &)(result));
25780 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25781 }
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25789 PyObject *resultobj;
25790 wxWindow *arg1 = (wxWindow *) 0 ;
25791 int *arg2 = (int *) 0 ;
25792 int *arg3 = (int *) 0 ;
25793 int temp2 ;
25794 int res2 = 0 ;
25795 int temp3 ;
25796 int res3 = 0 ;
25797 PyObject * obj0 = 0 ;
25798 char *kwnames[] = {
25799 (char *) "self", NULL
25800 };
25801
25802 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25803 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) 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 {
25808 PyThreadState* __tstate = wxPyBeginAllowThreads();
25809 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25810
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 Py_INCREF(Py_None); resultobj = Py_None;
25815 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25816 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25817 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25818 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25819 return resultobj;
25820 fail:
25821 return NULL;
25822 }
25823
25824
25825 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25826 PyObject *resultobj;
25827 wxWindow *arg1 = (wxWindow *) 0 ;
25828 wxRect result;
25829 PyObject * obj0 = 0 ;
25830 char *kwnames[] = {
25831 (char *) "self", NULL
25832 };
25833
25834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25836 if (SWIG_arg_fail(1)) SWIG_fail;
25837 {
25838 PyThreadState* __tstate = wxPyBeginAllowThreads();
25839 result = ((wxWindow const *)arg1)->GetRect();
25840
25841 wxPyEndAllowThreads(__tstate);
25842 if (PyErr_Occurred()) SWIG_fail;
25843 }
25844 {
25845 wxRect * resultptr;
25846 resultptr = new wxRect((wxRect &)(result));
25847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25848 }
25849 return resultobj;
25850 fail:
25851 return NULL;
25852 }
25853
25854
25855 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25856 PyObject *resultobj;
25857 wxWindow *arg1 = (wxWindow *) 0 ;
25858 wxSize result;
25859 PyObject * obj0 = 0 ;
25860 char *kwnames[] = {
25861 (char *) "self", NULL
25862 };
25863
25864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25866 if (SWIG_arg_fail(1)) SWIG_fail;
25867 {
25868 PyThreadState* __tstate = wxPyBeginAllowThreads();
25869 result = ((wxWindow const *)arg1)->GetClientSize();
25870
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 {
25875 wxSize * resultptr;
25876 resultptr = new wxSize((wxSize &)(result));
25877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25878 }
25879 return resultobj;
25880 fail:
25881 return NULL;
25882 }
25883
25884
25885 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25886 PyObject *resultobj;
25887 wxWindow *arg1 = (wxWindow *) 0 ;
25888 int *arg2 = (int *) 0 ;
25889 int *arg3 = (int *) 0 ;
25890 int temp2 ;
25891 int res2 = 0 ;
25892 int temp3 ;
25893 int res3 = 0 ;
25894 PyObject * obj0 = 0 ;
25895 char *kwnames[] = {
25896 (char *) "self", NULL
25897 };
25898
25899 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25900 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25903 if (SWIG_arg_fail(1)) SWIG_fail;
25904 {
25905 PyThreadState* __tstate = wxPyBeginAllowThreads();
25906 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25907
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 Py_INCREF(Py_None); resultobj = Py_None;
25912 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25913 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25914 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25915 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25916 return resultobj;
25917 fail:
25918 return NULL;
25919 }
25920
25921
25922 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25923 PyObject *resultobj;
25924 wxWindow *arg1 = (wxWindow *) 0 ;
25925 wxPoint result;
25926 PyObject * obj0 = 0 ;
25927 char *kwnames[] = {
25928 (char *) "self", NULL
25929 };
25930
25931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25933 if (SWIG_arg_fail(1)) SWIG_fail;
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25937
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 {
25942 wxPoint * resultptr;
25943 resultptr = new wxPoint((wxPoint &)(result));
25944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25945 }
25946 return resultobj;
25947 fail:
25948 return NULL;
25949 }
25950
25951
25952 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25953 PyObject *resultobj;
25954 wxWindow *arg1 = (wxWindow *) 0 ;
25955 wxRect result;
25956 PyObject * obj0 = 0 ;
25957 char *kwnames[] = {
25958 (char *) "self", NULL
25959 };
25960
25961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25963 if (SWIG_arg_fail(1)) SWIG_fail;
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 result = ((wxWindow const *)arg1)->GetClientRect();
25967
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 {
25972 wxRect * resultptr;
25973 resultptr = new wxRect((wxRect &)(result));
25974 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25975 }
25976 return resultobj;
25977 fail:
25978 return NULL;
25979 }
25980
25981
25982 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25983 PyObject *resultobj;
25984 wxWindow *arg1 = (wxWindow *) 0 ;
25985 wxSize result;
25986 PyObject * obj0 = 0 ;
25987 char *kwnames[] = {
25988 (char *) "self", NULL
25989 };
25990
25991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25993 if (SWIG_arg_fail(1)) SWIG_fail;
25994 {
25995 PyThreadState* __tstate = wxPyBeginAllowThreads();
25996 result = ((wxWindow const *)arg1)->GetBestSize();
25997
25998 wxPyEndAllowThreads(__tstate);
25999 if (PyErr_Occurred()) SWIG_fail;
26000 }
26001 {
26002 wxSize * resultptr;
26003 resultptr = new wxSize((wxSize &)(result));
26004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26005 }
26006 return resultobj;
26007 fail:
26008 return NULL;
26009 }
26010
26011
26012 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26013 PyObject *resultobj;
26014 wxWindow *arg1 = (wxWindow *) 0 ;
26015 int *arg2 = (int *) 0 ;
26016 int *arg3 = (int *) 0 ;
26017 int temp2 ;
26018 int res2 = 0 ;
26019 int temp3 ;
26020 int res3 = 0 ;
26021 PyObject * obj0 = 0 ;
26022 char *kwnames[] = {
26023 (char *) "self", NULL
26024 };
26025
26026 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26027 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26030 if (SWIG_arg_fail(1)) SWIG_fail;
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26034
26035 wxPyEndAllowThreads(__tstate);
26036 if (PyErr_Occurred()) SWIG_fail;
26037 }
26038 Py_INCREF(Py_None); resultobj = Py_None;
26039 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26040 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26041 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26042 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26043 return resultobj;
26044 fail:
26045 return NULL;
26046 }
26047
26048
26049 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26050 PyObject *resultobj;
26051 wxWindow *arg1 = (wxWindow *) 0 ;
26052 PyObject * obj0 = 0 ;
26053 char *kwnames[] = {
26054 (char *) "self", NULL
26055 };
26056
26057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26059 if (SWIG_arg_fail(1)) SWIG_fail;
26060 {
26061 PyThreadState* __tstate = wxPyBeginAllowThreads();
26062 (arg1)->InvalidateBestSize();
26063
26064 wxPyEndAllowThreads(__tstate);
26065 if (PyErr_Occurred()) SWIG_fail;
26066 }
26067 Py_INCREF(Py_None); resultobj = Py_None;
26068 return resultobj;
26069 fail:
26070 return NULL;
26071 }
26072
26073
26074 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26075 PyObject *resultobj;
26076 wxWindow *arg1 = (wxWindow *) 0 ;
26077 wxSize result;
26078 PyObject * obj0 = 0 ;
26079 char *kwnames[] = {
26080 (char *) "self", NULL
26081 };
26082
26083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26085 if (SWIG_arg_fail(1)) SWIG_fail;
26086 {
26087 PyThreadState* __tstate = wxPyBeginAllowThreads();
26088 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26089
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 {
26094 wxSize * resultptr;
26095 resultptr = new wxSize((wxSize &)(result));
26096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26097 }
26098 return resultobj;
26099 fail:
26100 return NULL;
26101 }
26102
26103
26104 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26105 PyObject *resultobj;
26106 wxWindow *arg1 = (wxWindow *) 0 ;
26107 wxSize result;
26108 PyObject * obj0 = 0 ;
26109 char *kwnames[] = {
26110 (char *) "self", NULL
26111 };
26112
26113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26115 if (SWIG_arg_fail(1)) SWIG_fail;
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26119
26120 wxPyEndAllowThreads(__tstate);
26121 if (PyErr_Occurred()) SWIG_fail;
26122 }
26123 {
26124 wxSize * resultptr;
26125 resultptr = new wxSize((wxSize &)(result));
26126 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26127 }
26128 return resultobj;
26129 fail:
26130 return NULL;
26131 }
26132
26133
26134 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26135 PyObject *resultobj;
26136 wxWindow *arg1 = (wxWindow *) 0 ;
26137 int arg2 = (int) wxBOTH ;
26138 PyObject * obj0 = 0 ;
26139 PyObject * obj1 = 0 ;
26140 char *kwnames[] = {
26141 (char *) "self",(char *) "direction", NULL
26142 };
26143
26144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26146 if (SWIG_arg_fail(1)) SWIG_fail;
26147 if (obj1) {
26148 {
26149 arg2 = (int)(SWIG_As_int(obj1));
26150 if (SWIG_arg_fail(2)) SWIG_fail;
26151 }
26152 }
26153 {
26154 PyThreadState* __tstate = wxPyBeginAllowThreads();
26155 (arg1)->Center(arg2);
26156
26157 wxPyEndAllowThreads(__tstate);
26158 if (PyErr_Occurred()) SWIG_fail;
26159 }
26160 Py_INCREF(Py_None); resultobj = Py_None;
26161 return resultobj;
26162 fail:
26163 return NULL;
26164 }
26165
26166
26167 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26168 PyObject *resultobj;
26169 wxWindow *arg1 = (wxWindow *) 0 ;
26170 int arg2 = (int) wxBOTH ;
26171 PyObject * obj0 = 0 ;
26172 PyObject * obj1 = 0 ;
26173 char *kwnames[] = {
26174 (char *) "self",(char *) "dir", NULL
26175 };
26176
26177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26179 if (SWIG_arg_fail(1)) SWIG_fail;
26180 if (obj1) {
26181 {
26182 arg2 = (int)(SWIG_As_int(obj1));
26183 if (SWIG_arg_fail(2)) SWIG_fail;
26184 }
26185 }
26186 {
26187 PyThreadState* __tstate = wxPyBeginAllowThreads();
26188 (arg1)->CenterOnScreen(arg2);
26189
26190 wxPyEndAllowThreads(__tstate);
26191 if (PyErr_Occurred()) SWIG_fail;
26192 }
26193 Py_INCREF(Py_None); resultobj = Py_None;
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26201 PyObject *resultobj;
26202 wxWindow *arg1 = (wxWindow *) 0 ;
26203 int arg2 = (int) wxBOTH ;
26204 PyObject * obj0 = 0 ;
26205 PyObject * obj1 = 0 ;
26206 char *kwnames[] = {
26207 (char *) "self",(char *) "dir", NULL
26208 };
26209
26210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26212 if (SWIG_arg_fail(1)) SWIG_fail;
26213 if (obj1) {
26214 {
26215 arg2 = (int)(SWIG_As_int(obj1));
26216 if (SWIG_arg_fail(2)) SWIG_fail;
26217 }
26218 }
26219 {
26220 PyThreadState* __tstate = wxPyBeginAllowThreads();
26221 (arg1)->CenterOnParent(arg2);
26222
26223 wxPyEndAllowThreads(__tstate);
26224 if (PyErr_Occurred()) SWIG_fail;
26225 }
26226 Py_INCREF(Py_None); resultobj = Py_None;
26227 return resultobj;
26228 fail:
26229 return NULL;
26230 }
26231
26232
26233 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26234 PyObject *resultobj;
26235 wxWindow *arg1 = (wxWindow *) 0 ;
26236 PyObject * obj0 = 0 ;
26237 char *kwnames[] = {
26238 (char *) "self", NULL
26239 };
26240
26241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26243 if (SWIG_arg_fail(1)) SWIG_fail;
26244 {
26245 PyThreadState* __tstate = wxPyBeginAllowThreads();
26246 (arg1)->Fit();
26247
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 Py_INCREF(Py_None); resultobj = Py_None;
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26259 PyObject *resultobj;
26260 wxWindow *arg1 = (wxWindow *) 0 ;
26261 PyObject * obj0 = 0 ;
26262 char *kwnames[] = {
26263 (char *) "self", NULL
26264 };
26265
26266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26268 if (SWIG_arg_fail(1)) SWIG_fail;
26269 {
26270 PyThreadState* __tstate = wxPyBeginAllowThreads();
26271 (arg1)->FitInside();
26272
26273 wxPyEndAllowThreads(__tstate);
26274 if (PyErr_Occurred()) SWIG_fail;
26275 }
26276 Py_INCREF(Py_None); resultobj = Py_None;
26277 return resultobj;
26278 fail:
26279 return NULL;
26280 }
26281
26282
26283 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26284 PyObject *resultobj;
26285 wxWindow *arg1 = (wxWindow *) 0 ;
26286 int arg2 ;
26287 int arg3 ;
26288 int arg4 = (int) -1 ;
26289 int arg5 = (int) -1 ;
26290 int arg6 = (int) -1 ;
26291 int arg7 = (int) -1 ;
26292 PyObject * obj0 = 0 ;
26293 PyObject * obj1 = 0 ;
26294 PyObject * obj2 = 0 ;
26295 PyObject * obj3 = 0 ;
26296 PyObject * obj4 = 0 ;
26297 PyObject * obj5 = 0 ;
26298 PyObject * obj6 = 0 ;
26299 char *kwnames[] = {
26300 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26301 };
26302
26303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26305 if (SWIG_arg_fail(1)) SWIG_fail;
26306 {
26307 arg2 = (int)(SWIG_As_int(obj1));
26308 if (SWIG_arg_fail(2)) SWIG_fail;
26309 }
26310 {
26311 arg3 = (int)(SWIG_As_int(obj2));
26312 if (SWIG_arg_fail(3)) SWIG_fail;
26313 }
26314 if (obj3) {
26315 {
26316 arg4 = (int)(SWIG_As_int(obj3));
26317 if (SWIG_arg_fail(4)) SWIG_fail;
26318 }
26319 }
26320 if (obj4) {
26321 {
26322 arg5 = (int)(SWIG_As_int(obj4));
26323 if (SWIG_arg_fail(5)) SWIG_fail;
26324 }
26325 }
26326 if (obj5) {
26327 {
26328 arg6 = (int)(SWIG_As_int(obj5));
26329 if (SWIG_arg_fail(6)) SWIG_fail;
26330 }
26331 }
26332 if (obj6) {
26333 {
26334 arg7 = (int)(SWIG_As_int(obj6));
26335 if (SWIG_arg_fail(7)) SWIG_fail;
26336 }
26337 }
26338 {
26339 PyThreadState* __tstate = wxPyBeginAllowThreads();
26340 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26341
26342 wxPyEndAllowThreads(__tstate);
26343 if (PyErr_Occurred()) SWIG_fail;
26344 }
26345 Py_INCREF(Py_None); resultobj = Py_None;
26346 return resultobj;
26347 fail:
26348 return NULL;
26349 }
26350
26351
26352 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26353 PyObject *resultobj;
26354 wxWindow *arg1 = (wxWindow *) 0 ;
26355 wxSize *arg2 = 0 ;
26356 wxSize const &arg3_defvalue = wxDefaultSize ;
26357 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26358 wxSize const &arg4_defvalue = wxDefaultSize ;
26359 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26360 wxSize temp2 ;
26361 wxSize temp3 ;
26362 wxSize temp4 ;
26363 PyObject * obj0 = 0 ;
26364 PyObject * obj1 = 0 ;
26365 PyObject * obj2 = 0 ;
26366 PyObject * obj3 = 0 ;
26367 char *kwnames[] = {
26368 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26369 };
26370
26371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26373 if (SWIG_arg_fail(1)) SWIG_fail;
26374 {
26375 arg2 = &temp2;
26376 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26377 }
26378 if (obj2) {
26379 {
26380 arg3 = &temp3;
26381 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26382 }
26383 }
26384 if (obj3) {
26385 {
26386 arg4 = &temp4;
26387 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26388 }
26389 }
26390 {
26391 PyThreadState* __tstate = wxPyBeginAllowThreads();
26392 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26393
26394 wxPyEndAllowThreads(__tstate);
26395 if (PyErr_Occurred()) SWIG_fail;
26396 }
26397 Py_INCREF(Py_None); resultobj = Py_None;
26398 return resultobj;
26399 fail:
26400 return NULL;
26401 }
26402
26403
26404 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26405 PyObject *resultobj;
26406 wxWindow *arg1 = (wxWindow *) 0 ;
26407 int arg2 ;
26408 int arg3 ;
26409 int arg4 = (int) -1 ;
26410 int arg5 = (int) -1 ;
26411 PyObject * obj0 = 0 ;
26412 PyObject * obj1 = 0 ;
26413 PyObject * obj2 = 0 ;
26414 PyObject * obj3 = 0 ;
26415 PyObject * obj4 = 0 ;
26416 char *kwnames[] = {
26417 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26418 };
26419
26420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26422 if (SWIG_arg_fail(1)) SWIG_fail;
26423 {
26424 arg2 = (int)(SWIG_As_int(obj1));
26425 if (SWIG_arg_fail(2)) SWIG_fail;
26426 }
26427 {
26428 arg3 = (int)(SWIG_As_int(obj2));
26429 if (SWIG_arg_fail(3)) SWIG_fail;
26430 }
26431 if (obj3) {
26432 {
26433 arg4 = (int)(SWIG_As_int(obj3));
26434 if (SWIG_arg_fail(4)) SWIG_fail;
26435 }
26436 }
26437 if (obj4) {
26438 {
26439 arg5 = (int)(SWIG_As_int(obj4));
26440 if (SWIG_arg_fail(5)) SWIG_fail;
26441 }
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26446
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 Py_INCREF(Py_None); resultobj = Py_None;
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj;
26459 wxWindow *arg1 = (wxWindow *) 0 ;
26460 wxSize *arg2 = 0 ;
26461 wxSize const &arg3_defvalue = wxDefaultSize ;
26462 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26463 wxSize temp2 ;
26464 wxSize temp3 ;
26465 PyObject * obj0 = 0 ;
26466 PyObject * obj1 = 0 ;
26467 PyObject * obj2 = 0 ;
26468 char *kwnames[] = {
26469 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26470 };
26471
26472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26474 if (SWIG_arg_fail(1)) SWIG_fail;
26475 {
26476 arg2 = &temp2;
26477 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26478 }
26479 if (obj2) {
26480 {
26481 arg3 = &temp3;
26482 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26483 }
26484 }
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26488
26489 wxPyEndAllowThreads(__tstate);
26490 if (PyErr_Occurred()) SWIG_fail;
26491 }
26492 Py_INCREF(Py_None); resultobj = Py_None;
26493 return resultobj;
26494 fail:
26495 return NULL;
26496 }
26497
26498
26499 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26500 PyObject *resultobj;
26501 wxWindow *arg1 = (wxWindow *) 0 ;
26502 wxSize result;
26503 PyObject * obj0 = 0 ;
26504 char *kwnames[] = {
26505 (char *) "self", NULL
26506 };
26507
26508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26510 if (SWIG_arg_fail(1)) SWIG_fail;
26511 {
26512 PyThreadState* __tstate = wxPyBeginAllowThreads();
26513 result = ((wxWindow const *)arg1)->GetMaxSize();
26514
26515 wxPyEndAllowThreads(__tstate);
26516 if (PyErr_Occurred()) SWIG_fail;
26517 }
26518 {
26519 wxSize * resultptr;
26520 resultptr = new wxSize((wxSize &)(result));
26521 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26522 }
26523 return resultobj;
26524 fail:
26525 return NULL;
26526 }
26527
26528
26529 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26530 PyObject *resultobj;
26531 wxWindow *arg1 = (wxWindow *) 0 ;
26532 wxSize result;
26533 PyObject * obj0 = 0 ;
26534 char *kwnames[] = {
26535 (char *) "self", NULL
26536 };
26537
26538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26540 if (SWIG_arg_fail(1)) SWIG_fail;
26541 {
26542 PyThreadState* __tstate = wxPyBeginAllowThreads();
26543 result = ((wxWindow const *)arg1)->GetMinSize();
26544
26545 wxPyEndAllowThreads(__tstate);
26546 if (PyErr_Occurred()) SWIG_fail;
26547 }
26548 {
26549 wxSize * resultptr;
26550 resultptr = new wxSize((wxSize &)(result));
26551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26552 }
26553 return resultobj;
26554 fail:
26555 return NULL;
26556 }
26557
26558
26559 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj;
26561 wxWindow *arg1 = (wxWindow *) 0 ;
26562 wxSize *arg2 = 0 ;
26563 wxSize temp2 ;
26564 PyObject * obj0 = 0 ;
26565 PyObject * obj1 = 0 ;
26566 char *kwnames[] = {
26567 (char *) "self",(char *) "minSize", NULL
26568 };
26569
26570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",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 {
26574 arg2 = &temp2;
26575 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26576 }
26577 {
26578 PyThreadState* __tstate = wxPyBeginAllowThreads();
26579 (arg1)->SetMinSize((wxSize const &)*arg2);
26580
26581 wxPyEndAllowThreads(__tstate);
26582 if (PyErr_Occurred()) SWIG_fail;
26583 }
26584 Py_INCREF(Py_None); resultobj = Py_None;
26585 return resultobj;
26586 fail:
26587 return NULL;
26588 }
26589
26590
26591 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26592 PyObject *resultobj;
26593 wxWindow *arg1 = (wxWindow *) 0 ;
26594 wxSize *arg2 = 0 ;
26595 wxSize temp2 ;
26596 PyObject * obj0 = 0 ;
26597 PyObject * obj1 = 0 ;
26598 char *kwnames[] = {
26599 (char *) "self",(char *) "maxSize", NULL
26600 };
26601
26602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26604 if (SWIG_arg_fail(1)) SWIG_fail;
26605 {
26606 arg2 = &temp2;
26607 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26608 }
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 (arg1)->SetMaxSize((wxSize const &)*arg2);
26612
26613 wxPyEndAllowThreads(__tstate);
26614 if (PyErr_Occurred()) SWIG_fail;
26615 }
26616 Py_INCREF(Py_None); resultobj = Py_None;
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26624 PyObject *resultobj;
26625 wxWindow *arg1 = (wxWindow *) 0 ;
26626 int result;
26627 PyObject * obj0 = 0 ;
26628 char *kwnames[] = {
26629 (char *) "self", NULL
26630 };
26631
26632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",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 = (int)((wxWindow const *)arg1)->GetMinWidth();
26638
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 {
26643 resultobj = SWIG_From_int((int)(result));
26644 }
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26652 PyObject *resultobj;
26653 wxWindow *arg1 = (wxWindow *) 0 ;
26654 int result;
26655 PyObject * obj0 = 0 ;
26656 char *kwnames[] = {
26657 (char *) "self", NULL
26658 };
26659
26660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",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 = (int)((wxWindow const *)arg1)->GetMinHeight();
26666
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 {
26671 resultobj = SWIG_From_int((int)(result));
26672 }
26673 return resultobj;
26674 fail:
26675 return NULL;
26676 }
26677
26678
26679 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj;
26681 wxWindow *arg1 = (wxWindow *) 0 ;
26682 int result;
26683 PyObject * obj0 = 0 ;
26684 char *kwnames[] = {
26685 (char *) "self", NULL
26686 };
26687
26688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26690 if (SWIG_arg_fail(1)) SWIG_fail;
26691 {
26692 PyThreadState* __tstate = wxPyBeginAllowThreads();
26693 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26694
26695 wxPyEndAllowThreads(__tstate);
26696 if (PyErr_Occurred()) SWIG_fail;
26697 }
26698 {
26699 resultobj = SWIG_From_int((int)(result));
26700 }
26701 return resultobj;
26702 fail:
26703 return NULL;
26704 }
26705
26706
26707 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26708 PyObject *resultobj;
26709 wxWindow *arg1 = (wxWindow *) 0 ;
26710 int result;
26711 PyObject * obj0 = 0 ;
26712 char *kwnames[] = {
26713 (char *) "self", NULL
26714 };
26715
26716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26718 if (SWIG_arg_fail(1)) SWIG_fail;
26719 {
26720 PyThreadState* __tstate = wxPyBeginAllowThreads();
26721 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26722
26723 wxPyEndAllowThreads(__tstate);
26724 if (PyErr_Occurred()) SWIG_fail;
26725 }
26726 {
26727 resultobj = SWIG_From_int((int)(result));
26728 }
26729 return resultobj;
26730 fail:
26731 return NULL;
26732 }
26733
26734
26735 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26736 PyObject *resultobj;
26737 wxWindow *arg1 = (wxWindow *) 0 ;
26738 wxSize *arg2 = 0 ;
26739 wxSize temp2 ;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 char *kwnames[] = {
26743 (char *) "self",(char *) "size", NULL
26744 };
26745
26746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26748 if (SWIG_arg_fail(1)) SWIG_fail;
26749 {
26750 arg2 = &temp2;
26751 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26752 }
26753 {
26754 PyThreadState* __tstate = wxPyBeginAllowThreads();
26755 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26756
26757 wxPyEndAllowThreads(__tstate);
26758 if (PyErr_Occurred()) SWIG_fail;
26759 }
26760 Py_INCREF(Py_None); resultobj = Py_None;
26761 return resultobj;
26762 fail:
26763 return NULL;
26764 }
26765
26766
26767 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26768 PyObject *resultobj;
26769 wxWindow *arg1 = (wxWindow *) 0 ;
26770 int arg2 ;
26771 int arg3 ;
26772 PyObject * obj0 = 0 ;
26773 PyObject * obj1 = 0 ;
26774 PyObject * obj2 = 0 ;
26775 char *kwnames[] = {
26776 (char *) "self",(char *) "w",(char *) "h", NULL
26777 };
26778
26779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26781 if (SWIG_arg_fail(1)) SWIG_fail;
26782 {
26783 arg2 = (int)(SWIG_As_int(obj1));
26784 if (SWIG_arg_fail(2)) SWIG_fail;
26785 }
26786 {
26787 arg3 = (int)(SWIG_As_int(obj2));
26788 if (SWIG_arg_fail(3)) SWIG_fail;
26789 }
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 (arg1)->SetVirtualSize(arg2,arg3);
26793
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 Py_INCREF(Py_None); resultobj = Py_None;
26798 return resultobj;
26799 fail:
26800 return NULL;
26801 }
26802
26803
26804 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26805 PyObject *resultobj;
26806 wxWindow *arg1 = (wxWindow *) 0 ;
26807 wxSize result;
26808 PyObject * obj0 = 0 ;
26809 char *kwnames[] = {
26810 (char *) "self", NULL
26811 };
26812
26813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26815 if (SWIG_arg_fail(1)) SWIG_fail;
26816 {
26817 PyThreadState* __tstate = wxPyBeginAllowThreads();
26818 result = ((wxWindow const *)arg1)->GetVirtualSize();
26819
26820 wxPyEndAllowThreads(__tstate);
26821 if (PyErr_Occurred()) SWIG_fail;
26822 }
26823 {
26824 wxSize * resultptr;
26825 resultptr = new wxSize((wxSize &)(result));
26826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26827 }
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26835 PyObject *resultobj;
26836 wxWindow *arg1 = (wxWindow *) 0 ;
26837 int *arg2 = (int *) 0 ;
26838 int *arg3 = (int *) 0 ;
26839 int temp2 ;
26840 int res2 = 0 ;
26841 int temp3 ;
26842 int res3 = 0 ;
26843 PyObject * obj0 = 0 ;
26844 char *kwnames[] = {
26845 (char *) "self", NULL
26846 };
26847
26848 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26849 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26852 if (SWIG_arg_fail(1)) SWIG_fail;
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26856
26857 wxPyEndAllowThreads(__tstate);
26858 if (PyErr_Occurred()) SWIG_fail;
26859 }
26860 Py_INCREF(Py_None); resultobj = Py_None;
26861 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26862 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26863 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26864 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26872 PyObject *resultobj;
26873 wxWindow *arg1 = (wxWindow *) 0 ;
26874 wxSize result;
26875 PyObject * obj0 = 0 ;
26876 char *kwnames[] = {
26877 (char *) "self", NULL
26878 };
26879
26880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26882 if (SWIG_arg_fail(1)) SWIG_fail;
26883 {
26884 PyThreadState* __tstate = wxPyBeginAllowThreads();
26885 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26886
26887 wxPyEndAllowThreads(__tstate);
26888 if (PyErr_Occurred()) SWIG_fail;
26889 }
26890 {
26891 wxSize * resultptr;
26892 resultptr = new wxSize((wxSize &)(result));
26893 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26894 }
26895 return resultobj;
26896 fail:
26897 return NULL;
26898 }
26899
26900
26901 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26902 PyObject *resultobj;
26903 wxWindow *arg1 = (wxWindow *) 0 ;
26904 bool arg2 = (bool) true ;
26905 bool result;
26906 PyObject * obj0 = 0 ;
26907 PyObject * obj1 = 0 ;
26908 char *kwnames[] = {
26909 (char *) "self",(char *) "show", NULL
26910 };
26911
26912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26914 if (SWIG_arg_fail(1)) SWIG_fail;
26915 if (obj1) {
26916 {
26917 arg2 = (bool)(SWIG_As_bool(obj1));
26918 if (SWIG_arg_fail(2)) SWIG_fail;
26919 }
26920 }
26921 {
26922 PyThreadState* __tstate = wxPyBeginAllowThreads();
26923 result = (bool)(arg1)->Show(arg2);
26924
26925 wxPyEndAllowThreads(__tstate);
26926 if (PyErr_Occurred()) SWIG_fail;
26927 }
26928 {
26929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26930 }
26931 return resultobj;
26932 fail:
26933 return NULL;
26934 }
26935
26936
26937 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26938 PyObject *resultobj;
26939 wxWindow *arg1 = (wxWindow *) 0 ;
26940 bool result;
26941 PyObject * obj0 = 0 ;
26942 char *kwnames[] = {
26943 (char *) "self", NULL
26944 };
26945
26946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26948 if (SWIG_arg_fail(1)) SWIG_fail;
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = (bool)(arg1)->Hide();
26952
26953 wxPyEndAllowThreads(__tstate);
26954 if (PyErr_Occurred()) SWIG_fail;
26955 }
26956 {
26957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26958 }
26959 return resultobj;
26960 fail:
26961 return NULL;
26962 }
26963
26964
26965 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26966 PyObject *resultobj;
26967 wxWindow *arg1 = (wxWindow *) 0 ;
26968 bool arg2 = (bool) true ;
26969 bool result;
26970 PyObject * obj0 = 0 ;
26971 PyObject * obj1 = 0 ;
26972 char *kwnames[] = {
26973 (char *) "self",(char *) "enable", NULL
26974 };
26975
26976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26978 if (SWIG_arg_fail(1)) SWIG_fail;
26979 if (obj1) {
26980 {
26981 arg2 = (bool)(SWIG_As_bool(obj1));
26982 if (SWIG_arg_fail(2)) SWIG_fail;
26983 }
26984 }
26985 {
26986 PyThreadState* __tstate = wxPyBeginAllowThreads();
26987 result = (bool)(arg1)->Enable(arg2);
26988
26989 wxPyEndAllowThreads(__tstate);
26990 if (PyErr_Occurred()) SWIG_fail;
26991 }
26992 {
26993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26994 }
26995 return resultobj;
26996 fail:
26997 return NULL;
26998 }
26999
27000
27001 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27002 PyObject *resultobj;
27003 wxWindow *arg1 = (wxWindow *) 0 ;
27004 bool result;
27005 PyObject * obj0 = 0 ;
27006 char *kwnames[] = {
27007 (char *) "self", NULL
27008 };
27009
27010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27012 if (SWIG_arg_fail(1)) SWIG_fail;
27013 {
27014 PyThreadState* __tstate = wxPyBeginAllowThreads();
27015 result = (bool)(arg1)->Disable();
27016
27017 wxPyEndAllowThreads(__tstate);
27018 if (PyErr_Occurred()) SWIG_fail;
27019 }
27020 {
27021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27022 }
27023 return resultobj;
27024 fail:
27025 return NULL;
27026 }
27027
27028
27029 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27030 PyObject *resultobj;
27031 wxWindow *arg1 = (wxWindow *) 0 ;
27032 bool result;
27033 PyObject * obj0 = 0 ;
27034 char *kwnames[] = {
27035 (char *) "self", NULL
27036 };
27037
27038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27040 if (SWIG_arg_fail(1)) SWIG_fail;
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 result = (bool)((wxWindow const *)arg1)->IsShown();
27044
27045 wxPyEndAllowThreads(__tstate);
27046 if (PyErr_Occurred()) SWIG_fail;
27047 }
27048 {
27049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27050 }
27051 return resultobj;
27052 fail:
27053 return NULL;
27054 }
27055
27056
27057 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27058 PyObject *resultobj;
27059 wxWindow *arg1 = (wxWindow *) 0 ;
27060 bool result;
27061 PyObject * obj0 = 0 ;
27062 char *kwnames[] = {
27063 (char *) "self", NULL
27064 };
27065
27066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27068 if (SWIG_arg_fail(1)) SWIG_fail;
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27072
27073 wxPyEndAllowThreads(__tstate);
27074 if (PyErr_Occurred()) SWIG_fail;
27075 }
27076 {
27077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27078 }
27079 return resultobj;
27080 fail:
27081 return NULL;
27082 }
27083
27084
27085 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27086 PyObject *resultobj;
27087 wxWindow *arg1 = (wxWindow *) 0 ;
27088 long arg2 ;
27089 PyObject * obj0 = 0 ;
27090 PyObject * obj1 = 0 ;
27091 char *kwnames[] = {
27092 (char *) "self",(char *) "style", NULL
27093 };
27094
27095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27097 if (SWIG_arg_fail(1)) SWIG_fail;
27098 {
27099 arg2 = (long)(SWIG_As_long(obj1));
27100 if (SWIG_arg_fail(2)) SWIG_fail;
27101 }
27102 {
27103 PyThreadState* __tstate = wxPyBeginAllowThreads();
27104 (arg1)->SetWindowStyleFlag(arg2);
27105
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 Py_INCREF(Py_None); resultobj = Py_None;
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27117 PyObject *resultobj;
27118 wxWindow *arg1 = (wxWindow *) 0 ;
27119 long result;
27120 PyObject * obj0 = 0 ;
27121 char *kwnames[] = {
27122 (char *) "self", NULL
27123 };
27124
27125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27127 if (SWIG_arg_fail(1)) SWIG_fail;
27128 {
27129 PyThreadState* __tstate = wxPyBeginAllowThreads();
27130 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27131
27132 wxPyEndAllowThreads(__tstate);
27133 if (PyErr_Occurred()) SWIG_fail;
27134 }
27135 {
27136 resultobj = SWIG_From_long((long)(result));
27137 }
27138 return resultobj;
27139 fail:
27140 return NULL;
27141 }
27142
27143
27144 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27145 PyObject *resultobj;
27146 wxWindow *arg1 = (wxWindow *) 0 ;
27147 int arg2 ;
27148 bool result;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char *kwnames[] = {
27152 (char *) "self",(char *) "flag", NULL
27153 };
27154
27155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27157 if (SWIG_arg_fail(1)) SWIG_fail;
27158 {
27159 arg2 = (int)(SWIG_As_int(obj1));
27160 if (SWIG_arg_fail(2)) SWIG_fail;
27161 }
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27165
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 {
27170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27171 }
27172 return resultobj;
27173 fail:
27174 return NULL;
27175 }
27176
27177
27178 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27179 PyObject *resultobj;
27180 wxWindow *arg1 = (wxWindow *) 0 ;
27181 bool result;
27182 PyObject * obj0 = 0 ;
27183 char *kwnames[] = {
27184 (char *) "self", NULL
27185 };
27186
27187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27189 if (SWIG_arg_fail(1)) SWIG_fail;
27190 {
27191 PyThreadState* __tstate = wxPyBeginAllowThreads();
27192 result = (bool)((wxWindow const *)arg1)->IsRetained();
27193
27194 wxPyEndAllowThreads(__tstate);
27195 if (PyErr_Occurred()) SWIG_fail;
27196 }
27197 {
27198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27199 }
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27207 PyObject *resultobj;
27208 wxWindow *arg1 = (wxWindow *) 0 ;
27209 long arg2 ;
27210 PyObject * obj0 = 0 ;
27211 PyObject * obj1 = 0 ;
27212 char *kwnames[] = {
27213 (char *) "self",(char *) "exStyle", NULL
27214 };
27215
27216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27218 if (SWIG_arg_fail(1)) SWIG_fail;
27219 {
27220 arg2 = (long)(SWIG_As_long(obj1));
27221 if (SWIG_arg_fail(2)) SWIG_fail;
27222 }
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 (arg1)->SetExtraStyle(arg2);
27226
27227 wxPyEndAllowThreads(__tstate);
27228 if (PyErr_Occurred()) SWIG_fail;
27229 }
27230 Py_INCREF(Py_None); resultobj = Py_None;
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27238 PyObject *resultobj;
27239 wxWindow *arg1 = (wxWindow *) 0 ;
27240 long result;
27241 PyObject * obj0 = 0 ;
27242 char *kwnames[] = {
27243 (char *) "self", NULL
27244 };
27245
27246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) 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 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27252
27253 wxPyEndAllowThreads(__tstate);
27254 if (PyErr_Occurred()) SWIG_fail;
27255 }
27256 {
27257 resultobj = SWIG_From_long((long)(result));
27258 }
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27266 PyObject *resultobj;
27267 wxWindow *arg1 = (wxWindow *) 0 ;
27268 bool arg2 = (bool) true ;
27269 PyObject * obj0 = 0 ;
27270 PyObject * obj1 = 0 ;
27271 char *kwnames[] = {
27272 (char *) "self",(char *) "modal", NULL
27273 };
27274
27275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27277 if (SWIG_arg_fail(1)) SWIG_fail;
27278 if (obj1) {
27279 {
27280 arg2 = (bool)(SWIG_As_bool(obj1));
27281 if (SWIG_arg_fail(2)) SWIG_fail;
27282 }
27283 }
27284 {
27285 PyThreadState* __tstate = wxPyBeginAllowThreads();
27286 (arg1)->MakeModal(arg2);
27287
27288 wxPyEndAllowThreads(__tstate);
27289 if (PyErr_Occurred()) SWIG_fail;
27290 }
27291 Py_INCREF(Py_None); resultobj = Py_None;
27292 return resultobj;
27293 fail:
27294 return NULL;
27295 }
27296
27297
27298 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27299 PyObject *resultobj;
27300 wxWindow *arg1 = (wxWindow *) 0 ;
27301 bool arg2 ;
27302 PyObject * obj0 = 0 ;
27303 PyObject * obj1 = 0 ;
27304 char *kwnames[] = {
27305 (char *) "self",(char *) "enableTheme", NULL
27306 };
27307
27308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27310 if (SWIG_arg_fail(1)) SWIG_fail;
27311 {
27312 arg2 = (bool)(SWIG_As_bool(obj1));
27313 if (SWIG_arg_fail(2)) SWIG_fail;
27314 }
27315 {
27316 PyThreadState* __tstate = wxPyBeginAllowThreads();
27317 (arg1)->SetThemeEnabled(arg2);
27318
27319 wxPyEndAllowThreads(__tstate);
27320 if (PyErr_Occurred()) SWIG_fail;
27321 }
27322 Py_INCREF(Py_None); resultobj = Py_None;
27323 return resultobj;
27324 fail:
27325 return NULL;
27326 }
27327
27328
27329 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27330 PyObject *resultobj;
27331 wxWindow *arg1 = (wxWindow *) 0 ;
27332 bool result;
27333 PyObject * obj0 = 0 ;
27334 char *kwnames[] = {
27335 (char *) "self", NULL
27336 };
27337
27338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27340 if (SWIG_arg_fail(1)) SWIG_fail;
27341 {
27342 PyThreadState* __tstate = wxPyBeginAllowThreads();
27343 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27344
27345 wxPyEndAllowThreads(__tstate);
27346 if (PyErr_Occurred()) SWIG_fail;
27347 }
27348 {
27349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27350 }
27351 return resultobj;
27352 fail:
27353 return NULL;
27354 }
27355
27356
27357 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27358 PyObject *resultobj;
27359 wxWindow *arg1 = (wxWindow *) 0 ;
27360 PyObject * obj0 = 0 ;
27361 char *kwnames[] = {
27362 (char *) "self", NULL
27363 };
27364
27365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27367 if (SWIG_arg_fail(1)) SWIG_fail;
27368 {
27369 PyThreadState* __tstate = wxPyBeginAllowThreads();
27370 (arg1)->SetFocus();
27371
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 Py_INCREF(Py_None); resultobj = Py_None;
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27383 PyObject *resultobj;
27384 wxWindow *arg1 = (wxWindow *) 0 ;
27385 PyObject * obj0 = 0 ;
27386 char *kwnames[] = {
27387 (char *) "self", NULL
27388 };
27389
27390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27392 if (SWIG_arg_fail(1)) SWIG_fail;
27393 {
27394 PyThreadState* __tstate = wxPyBeginAllowThreads();
27395 (arg1)->SetFocusFromKbd();
27396
27397 wxPyEndAllowThreads(__tstate);
27398 if (PyErr_Occurred()) SWIG_fail;
27399 }
27400 Py_INCREF(Py_None); resultobj = Py_None;
27401 return resultobj;
27402 fail:
27403 return NULL;
27404 }
27405
27406
27407 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27408 PyObject *resultobj;
27409 wxWindow *result;
27410 char *kwnames[] = {
27411 NULL
27412 };
27413
27414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27415 {
27416 if (!wxPyCheckForApp()) SWIG_fail;
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 result = (wxWindow *)wxWindow::FindFocus();
27419
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 {
27424 resultobj = wxPyMake_wxObject(result, 0);
27425 }
27426 return resultobj;
27427 fail:
27428 return NULL;
27429 }
27430
27431
27432 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27433 PyObject *resultobj;
27434 wxWindow *arg1 = (wxWindow *) 0 ;
27435 bool result;
27436 PyObject * obj0 = 0 ;
27437 char *kwnames[] = {
27438 (char *) "self", NULL
27439 };
27440
27441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27443 if (SWIG_arg_fail(1)) SWIG_fail;
27444 {
27445 PyThreadState* __tstate = wxPyBeginAllowThreads();
27446 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27447
27448 wxPyEndAllowThreads(__tstate);
27449 if (PyErr_Occurred()) SWIG_fail;
27450 }
27451 {
27452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27453 }
27454 return resultobj;
27455 fail:
27456 return NULL;
27457 }
27458
27459
27460 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27461 PyObject *resultobj;
27462 wxWindow *arg1 = (wxWindow *) 0 ;
27463 bool result;
27464 PyObject * obj0 = 0 ;
27465 char *kwnames[] = {
27466 (char *) "self", NULL
27467 };
27468
27469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27471 if (SWIG_arg_fail(1)) SWIG_fail;
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27475
27476 wxPyEndAllowThreads(__tstate);
27477 if (PyErr_Occurred()) SWIG_fail;
27478 }
27479 {
27480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27481 }
27482 return resultobj;
27483 fail:
27484 return NULL;
27485 }
27486
27487
27488 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27489 PyObject *resultobj;
27490 wxWindow *arg1 = (wxWindow *) 0 ;
27491 wxWindow *result;
27492 PyObject * obj0 = 0 ;
27493 char *kwnames[] = {
27494 (char *) "self", NULL
27495 };
27496
27497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27499 if (SWIG_arg_fail(1)) SWIG_fail;
27500 {
27501 PyThreadState* __tstate = wxPyBeginAllowThreads();
27502 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27503
27504 wxPyEndAllowThreads(__tstate);
27505 if (PyErr_Occurred()) SWIG_fail;
27506 }
27507 {
27508 resultobj = wxPyMake_wxObject(result, 0);
27509 }
27510 return resultobj;
27511 fail:
27512 return NULL;
27513 }
27514
27515
27516 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27517 PyObject *resultobj;
27518 wxWindow *arg1 = (wxWindow *) 0 ;
27519 wxWindow *arg2 = (wxWindow *) 0 ;
27520 wxWindow *result;
27521 PyObject * obj0 = 0 ;
27522 PyObject * obj1 = 0 ;
27523 char *kwnames[] = {
27524 (char *) "self",(char *) "child", NULL
27525 };
27526
27527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27529 if (SWIG_arg_fail(1)) SWIG_fail;
27530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27531 if (SWIG_arg_fail(2)) SWIG_fail;
27532 {
27533 PyThreadState* __tstate = wxPyBeginAllowThreads();
27534 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27535
27536 wxPyEndAllowThreads(__tstate);
27537 if (PyErr_Occurred()) SWIG_fail;
27538 }
27539 {
27540 resultobj = wxPyMake_wxObject(result, 0);
27541 }
27542 return resultobj;
27543 fail:
27544 return NULL;
27545 }
27546
27547
27548 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27549 PyObject *resultobj;
27550 wxWindow *arg1 = (wxWindow *) 0 ;
27551 wxWindow *arg2 = (wxWindow *) 0 ;
27552 PyObject * obj0 = 0 ;
27553 PyObject * obj1 = 0 ;
27554 char *kwnames[] = {
27555 (char *) "self",(char *) "win", NULL
27556 };
27557
27558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27560 if (SWIG_arg_fail(1)) SWIG_fail;
27561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27562 if (SWIG_arg_fail(2)) SWIG_fail;
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 (arg1)->SetTmpDefaultItem(arg2);
27566
27567 wxPyEndAllowThreads(__tstate);
27568 if (PyErr_Occurred()) SWIG_fail;
27569 }
27570 Py_INCREF(Py_None); resultobj = Py_None;
27571 return resultobj;
27572 fail:
27573 return NULL;
27574 }
27575
27576
27577 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27578 PyObject *resultobj;
27579 wxWindow *arg1 = (wxWindow *) 0 ;
27580 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27581 bool result;
27582 PyObject * obj0 = 0 ;
27583 PyObject * obj1 = 0 ;
27584 char *kwnames[] = {
27585 (char *) "self",(char *) "flags", NULL
27586 };
27587
27588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27590 if (SWIG_arg_fail(1)) SWIG_fail;
27591 if (obj1) {
27592 {
27593 arg2 = (int)(SWIG_As_int(obj1));
27594 if (SWIG_arg_fail(2)) SWIG_fail;
27595 }
27596 }
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (bool)(arg1)->Navigate(arg2);
27600
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 {
27605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27606 }
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27614 PyObject *resultobj;
27615 wxWindow *arg1 = (wxWindow *) 0 ;
27616 wxWindow *arg2 = (wxWindow *) 0 ;
27617 PyObject * obj0 = 0 ;
27618 PyObject * obj1 = 0 ;
27619 char *kwnames[] = {
27620 (char *) "self",(char *) "win", NULL
27621 };
27622
27623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27625 if (SWIG_arg_fail(1)) SWIG_fail;
27626 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27627 if (SWIG_arg_fail(2)) SWIG_fail;
27628 {
27629 PyThreadState* __tstate = wxPyBeginAllowThreads();
27630 (arg1)->MoveAfterInTabOrder(arg2);
27631
27632 wxPyEndAllowThreads(__tstate);
27633 if (PyErr_Occurred()) SWIG_fail;
27634 }
27635 Py_INCREF(Py_None); resultobj = Py_None;
27636 return resultobj;
27637 fail:
27638 return NULL;
27639 }
27640
27641
27642 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27643 PyObject *resultobj;
27644 wxWindow *arg1 = (wxWindow *) 0 ;
27645 wxWindow *arg2 = (wxWindow *) 0 ;
27646 PyObject * obj0 = 0 ;
27647 PyObject * obj1 = 0 ;
27648 char *kwnames[] = {
27649 (char *) "self",(char *) "win", NULL
27650 };
27651
27652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27654 if (SWIG_arg_fail(1)) SWIG_fail;
27655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27656 if (SWIG_arg_fail(2)) SWIG_fail;
27657 {
27658 PyThreadState* __tstate = wxPyBeginAllowThreads();
27659 (arg1)->MoveBeforeInTabOrder(arg2);
27660
27661 wxPyEndAllowThreads(__tstate);
27662 if (PyErr_Occurred()) SWIG_fail;
27663 }
27664 Py_INCREF(Py_None); resultobj = Py_None;
27665 return resultobj;
27666 fail:
27667 return NULL;
27668 }
27669
27670
27671 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27672 PyObject *resultobj;
27673 wxWindow *arg1 = (wxWindow *) 0 ;
27674 PyObject *result;
27675 PyObject * obj0 = 0 ;
27676 char *kwnames[] = {
27677 (char *) "self", NULL
27678 };
27679
27680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27682 if (SWIG_arg_fail(1)) SWIG_fail;
27683 {
27684 PyThreadState* __tstate = wxPyBeginAllowThreads();
27685 result = (PyObject *)wxWindow_GetChildren(arg1);
27686
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 resultobj = result;
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27698 PyObject *resultobj;
27699 wxWindow *arg1 = (wxWindow *) 0 ;
27700 wxWindow *result;
27701 PyObject * obj0 = 0 ;
27702 char *kwnames[] = {
27703 (char *) "self", NULL
27704 };
27705
27706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27708 if (SWIG_arg_fail(1)) SWIG_fail;
27709 {
27710 PyThreadState* __tstate = wxPyBeginAllowThreads();
27711 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27712
27713 wxPyEndAllowThreads(__tstate);
27714 if (PyErr_Occurred()) SWIG_fail;
27715 }
27716 {
27717 resultobj = wxPyMake_wxObject(result, 0);
27718 }
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj;
27727 wxWindow *arg1 = (wxWindow *) 0 ;
27728 wxWindow *result;
27729 PyObject * obj0 = 0 ;
27730 char *kwnames[] = {
27731 (char *) "self", NULL
27732 };
27733
27734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27736 if (SWIG_arg_fail(1)) SWIG_fail;
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27740
27741 wxPyEndAllowThreads(__tstate);
27742 if (PyErr_Occurred()) SWIG_fail;
27743 }
27744 {
27745 resultobj = wxPyMake_wxObject(result, 0);
27746 }
27747 return resultobj;
27748 fail:
27749 return NULL;
27750 }
27751
27752
27753 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27754 PyObject *resultobj;
27755 wxWindow *arg1 = (wxWindow *) 0 ;
27756 bool result;
27757 PyObject * obj0 = 0 ;
27758 char *kwnames[] = {
27759 (char *) "self", NULL
27760 };
27761
27762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27764 if (SWIG_arg_fail(1)) SWIG_fail;
27765 {
27766 PyThreadState* __tstate = wxPyBeginAllowThreads();
27767 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27768
27769 wxPyEndAllowThreads(__tstate);
27770 if (PyErr_Occurred()) SWIG_fail;
27771 }
27772 {
27773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27774 }
27775 return resultobj;
27776 fail:
27777 return NULL;
27778 }
27779
27780
27781 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27782 PyObject *resultobj;
27783 wxWindow *arg1 = (wxWindow *) 0 ;
27784 wxWindow *arg2 = (wxWindow *) 0 ;
27785 bool result;
27786 PyObject * obj0 = 0 ;
27787 PyObject * obj1 = 0 ;
27788 char *kwnames[] = {
27789 (char *) "self",(char *) "newParent", NULL
27790 };
27791
27792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27794 if (SWIG_arg_fail(1)) SWIG_fail;
27795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27796 if (SWIG_arg_fail(2)) SWIG_fail;
27797 {
27798 PyThreadState* __tstate = wxPyBeginAllowThreads();
27799 result = (bool)(arg1)->Reparent(arg2);
27800
27801 wxPyEndAllowThreads(__tstate);
27802 if (PyErr_Occurred()) SWIG_fail;
27803 }
27804 {
27805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27806 }
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27814 PyObject *resultobj;
27815 wxWindow *arg1 = (wxWindow *) 0 ;
27816 wxWindow *arg2 = (wxWindow *) 0 ;
27817 PyObject * obj0 = 0 ;
27818 PyObject * obj1 = 0 ;
27819 char *kwnames[] = {
27820 (char *) "self",(char *) "child", NULL
27821 };
27822
27823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27825 if (SWIG_arg_fail(1)) SWIG_fail;
27826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27827 if (SWIG_arg_fail(2)) SWIG_fail;
27828 {
27829 PyThreadState* __tstate = wxPyBeginAllowThreads();
27830 (arg1)->AddChild(arg2);
27831
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 Py_INCREF(Py_None); resultobj = Py_None;
27836 return resultobj;
27837 fail:
27838 return NULL;
27839 }
27840
27841
27842 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27843 PyObject *resultobj;
27844 wxWindow *arg1 = (wxWindow *) 0 ;
27845 wxWindow *arg2 = (wxWindow *) 0 ;
27846 PyObject * obj0 = 0 ;
27847 PyObject * obj1 = 0 ;
27848 char *kwnames[] = {
27849 (char *) "self",(char *) "child", NULL
27850 };
27851
27852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27856 if (SWIG_arg_fail(2)) SWIG_fail;
27857 {
27858 PyThreadState* __tstate = wxPyBeginAllowThreads();
27859 (arg1)->RemoveChild(arg2);
27860
27861 wxPyEndAllowThreads(__tstate);
27862 if (PyErr_Occurred()) SWIG_fail;
27863 }
27864 Py_INCREF(Py_None); resultobj = Py_None;
27865 return resultobj;
27866 fail:
27867 return NULL;
27868 }
27869
27870
27871 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27872 PyObject *resultobj;
27873 wxWindow *arg1 = (wxWindow *) 0 ;
27874 long arg2 ;
27875 wxWindow *result;
27876 PyObject * obj0 = 0 ;
27877 PyObject * obj1 = 0 ;
27878 char *kwnames[] = {
27879 (char *) "self",(char *) "winid", NULL
27880 };
27881
27882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27884 if (SWIG_arg_fail(1)) SWIG_fail;
27885 {
27886 arg2 = (long)(SWIG_As_long(obj1));
27887 if (SWIG_arg_fail(2)) SWIG_fail;
27888 }
27889 {
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (wxWindow *)(arg1)->FindWindow(arg2);
27892
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 {
27897 resultobj = wxPyMake_wxObject(result, 0);
27898 }
27899 return resultobj;
27900 fail:
27901 return NULL;
27902 }
27903
27904
27905 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27906 PyObject *resultobj;
27907 wxWindow *arg1 = (wxWindow *) 0 ;
27908 wxString *arg2 = 0 ;
27909 wxWindow *result;
27910 bool temp2 = false ;
27911 PyObject * obj0 = 0 ;
27912 PyObject * obj1 = 0 ;
27913 char *kwnames[] = {
27914 (char *) "self",(char *) "name", NULL
27915 };
27916
27917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27919 if (SWIG_arg_fail(1)) SWIG_fail;
27920 {
27921 arg2 = wxString_in_helper(obj1);
27922 if (arg2 == NULL) SWIG_fail;
27923 temp2 = true;
27924 }
27925 {
27926 PyThreadState* __tstate = wxPyBeginAllowThreads();
27927 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27928
27929 wxPyEndAllowThreads(__tstate);
27930 if (PyErr_Occurred()) SWIG_fail;
27931 }
27932 {
27933 resultobj = wxPyMake_wxObject(result, 0);
27934 }
27935 {
27936 if (temp2)
27937 delete arg2;
27938 }
27939 return resultobj;
27940 fail:
27941 {
27942 if (temp2)
27943 delete arg2;
27944 }
27945 return NULL;
27946 }
27947
27948
27949 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj;
27951 wxWindow *arg1 = (wxWindow *) 0 ;
27952 wxEvtHandler *result;
27953 PyObject * obj0 = 0 ;
27954 char *kwnames[] = {
27955 (char *) "self", NULL
27956 };
27957
27958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27960 if (SWIG_arg_fail(1)) SWIG_fail;
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27964
27965 wxPyEndAllowThreads(__tstate);
27966 if (PyErr_Occurred()) SWIG_fail;
27967 }
27968 {
27969 resultobj = wxPyMake_wxObject(result, 0);
27970 }
27971 return resultobj;
27972 fail:
27973 return NULL;
27974 }
27975
27976
27977 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27978 PyObject *resultobj;
27979 wxWindow *arg1 = (wxWindow *) 0 ;
27980 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27981 PyObject * obj0 = 0 ;
27982 PyObject * obj1 = 0 ;
27983 char *kwnames[] = {
27984 (char *) "self",(char *) "handler", NULL
27985 };
27986
27987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27989 if (SWIG_arg_fail(1)) SWIG_fail;
27990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27991 if (SWIG_arg_fail(2)) SWIG_fail;
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 (arg1)->SetEventHandler(arg2);
27995
27996 wxPyEndAllowThreads(__tstate);
27997 if (PyErr_Occurred()) SWIG_fail;
27998 }
27999 Py_INCREF(Py_None); resultobj = Py_None;
28000 return resultobj;
28001 fail:
28002 return NULL;
28003 }
28004
28005
28006 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28007 PyObject *resultobj;
28008 wxWindow *arg1 = (wxWindow *) 0 ;
28009 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28010 PyObject * obj0 = 0 ;
28011 PyObject * obj1 = 0 ;
28012 char *kwnames[] = {
28013 (char *) "self",(char *) "handler", NULL
28014 };
28015
28016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28018 if (SWIG_arg_fail(1)) SWIG_fail;
28019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28020 if (SWIG_arg_fail(2)) SWIG_fail;
28021 {
28022 PyThreadState* __tstate = wxPyBeginAllowThreads();
28023 (arg1)->PushEventHandler(arg2);
28024
28025 wxPyEndAllowThreads(__tstate);
28026 if (PyErr_Occurred()) SWIG_fail;
28027 }
28028 Py_INCREF(Py_None); resultobj = Py_None;
28029 return resultobj;
28030 fail:
28031 return NULL;
28032 }
28033
28034
28035 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28036 PyObject *resultobj;
28037 wxWindow *arg1 = (wxWindow *) 0 ;
28038 bool arg2 = (bool) false ;
28039 wxEvtHandler *result;
28040 PyObject * obj0 = 0 ;
28041 PyObject * obj1 = 0 ;
28042 char *kwnames[] = {
28043 (char *) "self",(char *) "deleteHandler", NULL
28044 };
28045
28046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28048 if (SWIG_arg_fail(1)) SWIG_fail;
28049 if (obj1) {
28050 {
28051 arg2 = (bool)(SWIG_As_bool(obj1));
28052 if (SWIG_arg_fail(2)) SWIG_fail;
28053 }
28054 }
28055 {
28056 PyThreadState* __tstate = wxPyBeginAllowThreads();
28057 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28058
28059 wxPyEndAllowThreads(__tstate);
28060 if (PyErr_Occurred()) SWIG_fail;
28061 }
28062 {
28063 resultobj = wxPyMake_wxObject(result, 0);
28064 }
28065 return resultobj;
28066 fail:
28067 return NULL;
28068 }
28069
28070
28071 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28072 PyObject *resultobj;
28073 wxWindow *arg1 = (wxWindow *) 0 ;
28074 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28075 bool result;
28076 PyObject * obj0 = 0 ;
28077 PyObject * obj1 = 0 ;
28078 char *kwnames[] = {
28079 (char *) "self",(char *) "handler", NULL
28080 };
28081
28082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28084 if (SWIG_arg_fail(1)) SWIG_fail;
28085 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28086 if (SWIG_arg_fail(2)) SWIG_fail;
28087 {
28088 PyThreadState* __tstate = wxPyBeginAllowThreads();
28089 result = (bool)(arg1)->RemoveEventHandler(arg2);
28090
28091 wxPyEndAllowThreads(__tstate);
28092 if (PyErr_Occurred()) SWIG_fail;
28093 }
28094 {
28095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28096 }
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj;
28105 wxWindow *arg1 = (wxWindow *) 0 ;
28106 wxValidator *arg2 = 0 ;
28107 PyObject * obj0 = 0 ;
28108 PyObject * obj1 = 0 ;
28109 char *kwnames[] = {
28110 (char *) "self",(char *) "validator", NULL
28111 };
28112
28113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28115 if (SWIG_arg_fail(1)) SWIG_fail;
28116 {
28117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28118 if (SWIG_arg_fail(2)) SWIG_fail;
28119 if (arg2 == NULL) {
28120 SWIG_null_ref("wxValidator");
28121 }
28122 if (SWIG_arg_fail(2)) SWIG_fail;
28123 }
28124 {
28125 PyThreadState* __tstate = wxPyBeginAllowThreads();
28126 (arg1)->SetValidator((wxValidator const &)*arg2);
28127
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 Py_INCREF(Py_None); resultobj = Py_None;
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28139 PyObject *resultobj;
28140 wxWindow *arg1 = (wxWindow *) 0 ;
28141 wxValidator *result;
28142 PyObject * obj0 = 0 ;
28143 char *kwnames[] = {
28144 (char *) "self", NULL
28145 };
28146
28147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28149 if (SWIG_arg_fail(1)) SWIG_fail;
28150 {
28151 PyThreadState* __tstate = wxPyBeginAllowThreads();
28152 result = (wxValidator *)(arg1)->GetValidator();
28153
28154 wxPyEndAllowThreads(__tstate);
28155 if (PyErr_Occurred()) SWIG_fail;
28156 }
28157 {
28158 resultobj = wxPyMake_wxObject(result, 0);
28159 }
28160 return resultobj;
28161 fail:
28162 return NULL;
28163 }
28164
28165
28166 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28167 PyObject *resultobj;
28168 wxWindow *arg1 = (wxWindow *) 0 ;
28169 bool result;
28170 PyObject * obj0 = 0 ;
28171 char *kwnames[] = {
28172 (char *) "self", NULL
28173 };
28174
28175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28177 if (SWIG_arg_fail(1)) SWIG_fail;
28178 {
28179 PyThreadState* __tstate = wxPyBeginAllowThreads();
28180 result = (bool)(arg1)->Validate();
28181
28182 wxPyEndAllowThreads(__tstate);
28183 if (PyErr_Occurred()) SWIG_fail;
28184 }
28185 {
28186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28187 }
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj;
28196 wxWindow *arg1 = (wxWindow *) 0 ;
28197 bool result;
28198 PyObject * obj0 = 0 ;
28199 char *kwnames[] = {
28200 (char *) "self", NULL
28201 };
28202
28203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28205 if (SWIG_arg_fail(1)) SWIG_fail;
28206 {
28207 PyThreadState* __tstate = wxPyBeginAllowThreads();
28208 result = (bool)(arg1)->TransferDataToWindow();
28209
28210 wxPyEndAllowThreads(__tstate);
28211 if (PyErr_Occurred()) SWIG_fail;
28212 }
28213 {
28214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28215 }
28216 return resultobj;
28217 fail:
28218 return NULL;
28219 }
28220
28221
28222 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28223 PyObject *resultobj;
28224 wxWindow *arg1 = (wxWindow *) 0 ;
28225 bool result;
28226 PyObject * obj0 = 0 ;
28227 char *kwnames[] = {
28228 (char *) "self", NULL
28229 };
28230
28231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28233 if (SWIG_arg_fail(1)) SWIG_fail;
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (bool)(arg1)->TransferDataFromWindow();
28237
28238 wxPyEndAllowThreads(__tstate);
28239 if (PyErr_Occurred()) SWIG_fail;
28240 }
28241 {
28242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28243 }
28244 return resultobj;
28245 fail:
28246 return NULL;
28247 }
28248
28249
28250 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28251 PyObject *resultobj;
28252 wxWindow *arg1 = (wxWindow *) 0 ;
28253 PyObject * obj0 = 0 ;
28254 char *kwnames[] = {
28255 (char *) "self", NULL
28256 };
28257
28258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28260 if (SWIG_arg_fail(1)) SWIG_fail;
28261 {
28262 PyThreadState* __tstate = wxPyBeginAllowThreads();
28263 (arg1)->InitDialog();
28264
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 Py_INCREF(Py_None); resultobj = Py_None;
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28276 PyObject *resultobj;
28277 wxWindow *arg1 = (wxWindow *) 0 ;
28278 wxAcceleratorTable *arg2 = 0 ;
28279 PyObject * obj0 = 0 ;
28280 PyObject * obj1 = 0 ;
28281 char *kwnames[] = {
28282 (char *) "self",(char *) "accel", NULL
28283 };
28284
28285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28287 if (SWIG_arg_fail(1)) SWIG_fail;
28288 {
28289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28290 if (SWIG_arg_fail(2)) SWIG_fail;
28291 if (arg2 == NULL) {
28292 SWIG_null_ref("wxAcceleratorTable");
28293 }
28294 if (SWIG_arg_fail(2)) SWIG_fail;
28295 }
28296 {
28297 PyThreadState* __tstate = wxPyBeginAllowThreads();
28298 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28299
28300 wxPyEndAllowThreads(__tstate);
28301 if (PyErr_Occurred()) SWIG_fail;
28302 }
28303 Py_INCREF(Py_None); resultobj = Py_None;
28304 return resultobj;
28305 fail:
28306 return NULL;
28307 }
28308
28309
28310 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28311 PyObject *resultobj;
28312 wxWindow *arg1 = (wxWindow *) 0 ;
28313 wxAcceleratorTable *result;
28314 PyObject * obj0 = 0 ;
28315 char *kwnames[] = {
28316 (char *) "self", NULL
28317 };
28318
28319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28321 if (SWIG_arg_fail(1)) SWIG_fail;
28322 {
28323 PyThreadState* __tstate = wxPyBeginAllowThreads();
28324 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28325
28326 wxPyEndAllowThreads(__tstate);
28327 if (PyErr_Occurred()) SWIG_fail;
28328 }
28329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28330 return resultobj;
28331 fail:
28332 return NULL;
28333 }
28334
28335
28336 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28337 PyObject *resultobj;
28338 wxWindow *arg1 = (wxWindow *) 0 ;
28339 int arg2 ;
28340 int arg3 ;
28341 int arg4 ;
28342 bool result;
28343 PyObject * obj0 = 0 ;
28344 PyObject * obj1 = 0 ;
28345 PyObject * obj2 = 0 ;
28346 PyObject * obj3 = 0 ;
28347 char *kwnames[] = {
28348 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28349 };
28350
28351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28353 if (SWIG_arg_fail(1)) SWIG_fail;
28354 {
28355 arg2 = (int)(SWIG_As_int(obj1));
28356 if (SWIG_arg_fail(2)) SWIG_fail;
28357 }
28358 {
28359 arg3 = (int)(SWIG_As_int(obj2));
28360 if (SWIG_arg_fail(3)) SWIG_fail;
28361 }
28362 {
28363 arg4 = (int)(SWIG_As_int(obj3));
28364 if (SWIG_arg_fail(4)) SWIG_fail;
28365 }
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28369
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 {
28374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28375 }
28376 return resultobj;
28377 fail:
28378 return NULL;
28379 }
28380
28381
28382 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28383 PyObject *resultobj;
28384 wxWindow *arg1 = (wxWindow *) 0 ;
28385 int arg2 ;
28386 bool result;
28387 PyObject * obj0 = 0 ;
28388 PyObject * obj1 = 0 ;
28389 char *kwnames[] = {
28390 (char *) "self",(char *) "hotkeyId", NULL
28391 };
28392
28393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28395 if (SWIG_arg_fail(1)) SWIG_fail;
28396 {
28397 arg2 = (int)(SWIG_As_int(obj1));
28398 if (SWIG_arg_fail(2)) SWIG_fail;
28399 }
28400 {
28401 PyThreadState* __tstate = wxPyBeginAllowThreads();
28402 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28403
28404 wxPyEndAllowThreads(__tstate);
28405 if (PyErr_Occurred()) SWIG_fail;
28406 }
28407 {
28408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28409 }
28410 return resultobj;
28411 fail:
28412 return NULL;
28413 }
28414
28415
28416 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28417 PyObject *resultobj;
28418 wxWindow *arg1 = (wxWindow *) 0 ;
28419 wxPoint *arg2 = 0 ;
28420 wxPoint result;
28421 wxPoint temp2 ;
28422 PyObject * obj0 = 0 ;
28423 PyObject * obj1 = 0 ;
28424 char *kwnames[] = {
28425 (char *) "self",(char *) "pt", NULL
28426 };
28427
28428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28430 if (SWIG_arg_fail(1)) SWIG_fail;
28431 {
28432 arg2 = &temp2;
28433 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28434 }
28435 {
28436 PyThreadState* __tstate = wxPyBeginAllowThreads();
28437 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28438
28439 wxPyEndAllowThreads(__tstate);
28440 if (PyErr_Occurred()) SWIG_fail;
28441 }
28442 {
28443 wxPoint * resultptr;
28444 resultptr = new wxPoint((wxPoint &)(result));
28445 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28446 }
28447 return resultobj;
28448 fail:
28449 return NULL;
28450 }
28451
28452
28453 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28454 PyObject *resultobj;
28455 wxWindow *arg1 = (wxWindow *) 0 ;
28456 wxSize *arg2 = 0 ;
28457 wxSize result;
28458 wxSize temp2 ;
28459 PyObject * obj0 = 0 ;
28460 PyObject * obj1 = 0 ;
28461 char *kwnames[] = {
28462 (char *) "self",(char *) "sz", NULL
28463 };
28464
28465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28467 if (SWIG_arg_fail(1)) SWIG_fail;
28468 {
28469 arg2 = &temp2;
28470 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28471 }
28472 {
28473 PyThreadState* __tstate = wxPyBeginAllowThreads();
28474 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28475
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 {
28480 wxSize * resultptr;
28481 resultptr = new wxSize((wxSize &)(result));
28482 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28483 }
28484 return resultobj;
28485 fail:
28486 return NULL;
28487 }
28488
28489
28490 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28491 PyObject *resultobj;
28492 wxWindow *arg1 = (wxWindow *) 0 ;
28493 wxPoint *arg2 = 0 ;
28494 wxPoint result;
28495 wxPoint temp2 ;
28496 PyObject * obj0 = 0 ;
28497 PyObject * obj1 = 0 ;
28498 char *kwnames[] = {
28499 (char *) "self",(char *) "pt", NULL
28500 };
28501
28502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28504 if (SWIG_arg_fail(1)) SWIG_fail;
28505 {
28506 arg2 = &temp2;
28507 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28508 }
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28512
28513 wxPyEndAllowThreads(__tstate);
28514 if (PyErr_Occurred()) SWIG_fail;
28515 }
28516 {
28517 wxPoint * resultptr;
28518 resultptr = new wxPoint((wxPoint &)(result));
28519 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28520 }
28521 return resultobj;
28522 fail:
28523 return NULL;
28524 }
28525
28526
28527 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28528 PyObject *resultobj;
28529 wxWindow *arg1 = (wxWindow *) 0 ;
28530 wxSize *arg2 = 0 ;
28531 wxSize result;
28532 wxSize temp2 ;
28533 PyObject * obj0 = 0 ;
28534 PyObject * obj1 = 0 ;
28535 char *kwnames[] = {
28536 (char *) "self",(char *) "sz", NULL
28537 };
28538
28539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28541 if (SWIG_arg_fail(1)) SWIG_fail;
28542 {
28543 arg2 = &temp2;
28544 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28545 }
28546 {
28547 PyThreadState* __tstate = wxPyBeginAllowThreads();
28548 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28549
28550 wxPyEndAllowThreads(__tstate);
28551 if (PyErr_Occurred()) SWIG_fail;
28552 }
28553 {
28554 wxSize * resultptr;
28555 resultptr = new wxSize((wxSize &)(result));
28556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28557 }
28558 return resultobj;
28559 fail:
28560 return NULL;
28561 }
28562
28563
28564 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28565 PyObject *resultobj;
28566 wxWindow *arg1 = (wxWindow *) 0 ;
28567 wxPoint *arg2 = 0 ;
28568 wxPoint result;
28569 wxPoint temp2 ;
28570 PyObject * obj0 = 0 ;
28571 PyObject * obj1 = 0 ;
28572 char *kwnames[] = {
28573 (char *) "self",(char *) "pt", NULL
28574 };
28575
28576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28578 if (SWIG_arg_fail(1)) SWIG_fail;
28579 {
28580 arg2 = &temp2;
28581 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28582 }
28583 {
28584 PyThreadState* __tstate = wxPyBeginAllowThreads();
28585 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28586
28587 wxPyEndAllowThreads(__tstate);
28588 if (PyErr_Occurred()) SWIG_fail;
28589 }
28590 {
28591 wxPoint * resultptr;
28592 resultptr = new wxPoint((wxPoint &)(result));
28593 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28594 }
28595 return resultobj;
28596 fail:
28597 return NULL;
28598 }
28599
28600
28601 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28602 PyObject *resultobj;
28603 wxWindow *arg1 = (wxWindow *) 0 ;
28604 wxSize *arg2 = 0 ;
28605 wxSize result;
28606 wxSize temp2 ;
28607 PyObject * obj0 = 0 ;
28608 PyObject * obj1 = 0 ;
28609 char *kwnames[] = {
28610 (char *) "self",(char *) "sz", NULL
28611 };
28612
28613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28615 if (SWIG_arg_fail(1)) SWIG_fail;
28616 {
28617 arg2 = &temp2;
28618 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28619 }
28620 {
28621 PyThreadState* __tstate = wxPyBeginAllowThreads();
28622 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28623
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 {
28628 wxSize * resultptr;
28629 resultptr = new wxSize((wxSize &)(result));
28630 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28631 }
28632 return resultobj;
28633 fail:
28634 return NULL;
28635 }
28636
28637
28638 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28639 PyObject *resultobj;
28640 wxWindow *arg1 = (wxWindow *) 0 ;
28641 int arg2 ;
28642 int arg3 ;
28643 PyObject * obj0 = 0 ;
28644 PyObject * obj1 = 0 ;
28645 PyObject * obj2 = 0 ;
28646 char *kwnames[] = {
28647 (char *) "self",(char *) "x",(char *) "y", NULL
28648 };
28649
28650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28652 if (SWIG_arg_fail(1)) SWIG_fail;
28653 {
28654 arg2 = (int)(SWIG_As_int(obj1));
28655 if (SWIG_arg_fail(2)) SWIG_fail;
28656 }
28657 {
28658 arg3 = (int)(SWIG_As_int(obj2));
28659 if (SWIG_arg_fail(3)) SWIG_fail;
28660 }
28661 {
28662 PyThreadState* __tstate = wxPyBeginAllowThreads();
28663 (arg1)->WarpPointer(arg2,arg3);
28664
28665 wxPyEndAllowThreads(__tstate);
28666 if (PyErr_Occurred()) SWIG_fail;
28667 }
28668 Py_INCREF(Py_None); resultobj = Py_None;
28669 return resultobj;
28670 fail:
28671 return NULL;
28672 }
28673
28674
28675 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28676 PyObject *resultobj;
28677 wxWindow *arg1 = (wxWindow *) 0 ;
28678 PyObject * obj0 = 0 ;
28679 char *kwnames[] = {
28680 (char *) "self", NULL
28681 };
28682
28683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28685 if (SWIG_arg_fail(1)) SWIG_fail;
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 (arg1)->CaptureMouse();
28689
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 Py_INCREF(Py_None); resultobj = Py_None;
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28701 PyObject *resultobj;
28702 wxWindow *arg1 = (wxWindow *) 0 ;
28703 PyObject * obj0 = 0 ;
28704 char *kwnames[] = {
28705 (char *) "self", NULL
28706 };
28707
28708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28710 if (SWIG_arg_fail(1)) SWIG_fail;
28711 {
28712 PyThreadState* __tstate = wxPyBeginAllowThreads();
28713 (arg1)->ReleaseMouse();
28714
28715 wxPyEndAllowThreads(__tstate);
28716 if (PyErr_Occurred()) SWIG_fail;
28717 }
28718 Py_INCREF(Py_None); resultobj = Py_None;
28719 return resultobj;
28720 fail:
28721 return NULL;
28722 }
28723
28724
28725 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28726 PyObject *resultobj;
28727 wxWindow *result;
28728 char *kwnames[] = {
28729 NULL
28730 };
28731
28732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28733 {
28734 if (!wxPyCheckForApp()) SWIG_fail;
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 result = (wxWindow *)wxWindow::GetCapture();
28737
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 {
28742 resultobj = wxPyMake_wxObject(result, 0);
28743 }
28744 return resultobj;
28745 fail:
28746 return NULL;
28747 }
28748
28749
28750 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28751 PyObject *resultobj;
28752 wxWindow *arg1 = (wxWindow *) 0 ;
28753 bool result;
28754 PyObject * obj0 = 0 ;
28755 char *kwnames[] = {
28756 (char *) "self", NULL
28757 };
28758
28759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28761 if (SWIG_arg_fail(1)) SWIG_fail;
28762 {
28763 PyThreadState* __tstate = wxPyBeginAllowThreads();
28764 result = (bool)((wxWindow const *)arg1)->HasCapture();
28765
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 {
28770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28771 }
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28779 PyObject *resultobj;
28780 wxWindow *arg1 = (wxWindow *) 0 ;
28781 bool arg2 = (bool) true ;
28782 wxRect *arg3 = (wxRect *) NULL ;
28783 PyObject * obj0 = 0 ;
28784 PyObject * obj1 = 0 ;
28785 PyObject * obj2 = 0 ;
28786 char *kwnames[] = {
28787 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28788 };
28789
28790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28792 if (SWIG_arg_fail(1)) SWIG_fail;
28793 if (obj1) {
28794 {
28795 arg2 = (bool)(SWIG_As_bool(obj1));
28796 if (SWIG_arg_fail(2)) SWIG_fail;
28797 }
28798 }
28799 if (obj2) {
28800 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28801 if (SWIG_arg_fail(3)) SWIG_fail;
28802 }
28803 {
28804 PyThreadState* __tstate = wxPyBeginAllowThreads();
28805 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28806
28807 wxPyEndAllowThreads(__tstate);
28808 if (PyErr_Occurred()) SWIG_fail;
28809 }
28810 Py_INCREF(Py_None); resultobj = Py_None;
28811 return resultobj;
28812 fail:
28813 return NULL;
28814 }
28815
28816
28817 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28818 PyObject *resultobj;
28819 wxWindow *arg1 = (wxWindow *) 0 ;
28820 wxRect *arg2 = 0 ;
28821 bool arg3 = (bool) true ;
28822 wxRect temp2 ;
28823 PyObject * obj0 = 0 ;
28824 PyObject * obj1 = 0 ;
28825 PyObject * obj2 = 0 ;
28826 char *kwnames[] = {
28827 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28828 };
28829
28830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28832 if (SWIG_arg_fail(1)) SWIG_fail;
28833 {
28834 arg2 = &temp2;
28835 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28836 }
28837 if (obj2) {
28838 {
28839 arg3 = (bool)(SWIG_As_bool(obj2));
28840 if (SWIG_arg_fail(3)) SWIG_fail;
28841 }
28842 }
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28846
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 Py_INCREF(Py_None); resultobj = Py_None;
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj;
28859 wxWindow *arg1 = (wxWindow *) 0 ;
28860 PyObject * obj0 = 0 ;
28861 char *kwnames[] = {
28862 (char *) "self", NULL
28863 };
28864
28865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28867 if (SWIG_arg_fail(1)) SWIG_fail;
28868 {
28869 PyThreadState* __tstate = wxPyBeginAllowThreads();
28870 (arg1)->Update();
28871
28872 wxPyEndAllowThreads(__tstate);
28873 if (PyErr_Occurred()) SWIG_fail;
28874 }
28875 Py_INCREF(Py_None); resultobj = Py_None;
28876 return resultobj;
28877 fail:
28878 return NULL;
28879 }
28880
28881
28882 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj;
28884 wxWindow *arg1 = (wxWindow *) 0 ;
28885 PyObject * obj0 = 0 ;
28886 char *kwnames[] = {
28887 (char *) "self", NULL
28888 };
28889
28890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28892 if (SWIG_arg_fail(1)) SWIG_fail;
28893 {
28894 PyThreadState* __tstate = wxPyBeginAllowThreads();
28895 (arg1)->ClearBackground();
28896
28897 wxPyEndAllowThreads(__tstate);
28898 if (PyErr_Occurred()) SWIG_fail;
28899 }
28900 Py_INCREF(Py_None); resultobj = Py_None;
28901 return resultobj;
28902 fail:
28903 return NULL;
28904 }
28905
28906
28907 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28908 PyObject *resultobj;
28909 wxWindow *arg1 = (wxWindow *) 0 ;
28910 PyObject * obj0 = 0 ;
28911 char *kwnames[] = {
28912 (char *) "self", NULL
28913 };
28914
28915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28917 if (SWIG_arg_fail(1)) SWIG_fail;
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 (arg1)->Freeze();
28921
28922 wxPyEndAllowThreads(__tstate);
28923 if (PyErr_Occurred()) SWIG_fail;
28924 }
28925 Py_INCREF(Py_None); resultobj = Py_None;
28926 return resultobj;
28927 fail:
28928 return NULL;
28929 }
28930
28931
28932 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28933 PyObject *resultobj;
28934 wxWindow *arg1 = (wxWindow *) 0 ;
28935 PyObject * obj0 = 0 ;
28936 char *kwnames[] = {
28937 (char *) "self", NULL
28938 };
28939
28940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28942 if (SWIG_arg_fail(1)) SWIG_fail;
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 (arg1)->Thaw();
28946
28947 wxPyEndAllowThreads(__tstate);
28948 if (PyErr_Occurred()) SWIG_fail;
28949 }
28950 Py_INCREF(Py_None); resultobj = Py_None;
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28958 PyObject *resultobj;
28959 wxWindow *arg1 = (wxWindow *) 0 ;
28960 wxDC *arg2 = 0 ;
28961 PyObject * obj0 = 0 ;
28962 PyObject * obj1 = 0 ;
28963 char *kwnames[] = {
28964 (char *) "self",(char *) "dc", NULL
28965 };
28966
28967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28969 if (SWIG_arg_fail(1)) SWIG_fail;
28970 {
28971 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28972 if (SWIG_arg_fail(2)) SWIG_fail;
28973 if (arg2 == NULL) {
28974 SWIG_null_ref("wxDC");
28975 }
28976 if (SWIG_arg_fail(2)) SWIG_fail;
28977 }
28978 {
28979 PyThreadState* __tstate = wxPyBeginAllowThreads();
28980 (arg1)->PrepareDC(*arg2);
28981
28982 wxPyEndAllowThreads(__tstate);
28983 if (PyErr_Occurred()) SWIG_fail;
28984 }
28985 Py_INCREF(Py_None); resultobj = Py_None;
28986 return resultobj;
28987 fail:
28988 return NULL;
28989 }
28990
28991
28992 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28993 PyObject *resultobj;
28994 wxWindow *arg1 = (wxWindow *) 0 ;
28995 wxRegion *result;
28996 PyObject * obj0 = 0 ;
28997 char *kwnames[] = {
28998 (char *) "self", NULL
28999 };
29000
29001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",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 {
29007 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29008 result = (wxRegion *) &_result_ref;
29009 }
29010
29011 wxPyEndAllowThreads(__tstate);
29012 if (PyErr_Occurred()) SWIG_fail;
29013 }
29014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29022 PyObject *resultobj;
29023 wxWindow *arg1 = (wxWindow *) 0 ;
29024 wxRect result;
29025 PyObject * obj0 = 0 ;
29026 char *kwnames[] = {
29027 (char *) "self", NULL
29028 };
29029
29030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29032 if (SWIG_arg_fail(1)) SWIG_fail;
29033 {
29034 PyThreadState* __tstate = wxPyBeginAllowThreads();
29035 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29036
29037 wxPyEndAllowThreads(__tstate);
29038 if (PyErr_Occurred()) SWIG_fail;
29039 }
29040 {
29041 wxRect * resultptr;
29042 resultptr = new wxRect((wxRect &)(result));
29043 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29044 }
29045 return resultobj;
29046 fail:
29047 return NULL;
29048 }
29049
29050
29051 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29052 PyObject *resultobj;
29053 wxWindow *arg1 = (wxWindow *) 0 ;
29054 int arg2 ;
29055 int arg3 ;
29056 int arg4 = (int) 1 ;
29057 int arg5 = (int) 1 ;
29058 bool result;
29059 PyObject * obj0 = 0 ;
29060 PyObject * obj1 = 0 ;
29061 PyObject * obj2 = 0 ;
29062 PyObject * obj3 = 0 ;
29063 PyObject * obj4 = 0 ;
29064 char *kwnames[] = {
29065 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29066 };
29067
29068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29070 if (SWIG_arg_fail(1)) SWIG_fail;
29071 {
29072 arg2 = (int)(SWIG_As_int(obj1));
29073 if (SWIG_arg_fail(2)) SWIG_fail;
29074 }
29075 {
29076 arg3 = (int)(SWIG_As_int(obj2));
29077 if (SWIG_arg_fail(3)) SWIG_fail;
29078 }
29079 if (obj3) {
29080 {
29081 arg4 = (int)(SWIG_As_int(obj3));
29082 if (SWIG_arg_fail(4)) SWIG_fail;
29083 }
29084 }
29085 if (obj4) {
29086 {
29087 arg5 = (int)(SWIG_As_int(obj4));
29088 if (SWIG_arg_fail(5)) SWIG_fail;
29089 }
29090 }
29091 {
29092 PyThreadState* __tstate = wxPyBeginAllowThreads();
29093 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29094
29095 wxPyEndAllowThreads(__tstate);
29096 if (PyErr_Occurred()) SWIG_fail;
29097 }
29098 {
29099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29100 }
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29108 PyObject *resultobj;
29109 wxWindow *arg1 = (wxWindow *) 0 ;
29110 wxPoint *arg2 = 0 ;
29111 bool result;
29112 wxPoint temp2 ;
29113 PyObject * obj0 = 0 ;
29114 PyObject * obj1 = 0 ;
29115 char *kwnames[] = {
29116 (char *) "self",(char *) "pt", NULL
29117 };
29118
29119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29121 if (SWIG_arg_fail(1)) SWIG_fail;
29122 {
29123 arg2 = &temp2;
29124 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29125 }
29126 {
29127 PyThreadState* __tstate = wxPyBeginAllowThreads();
29128 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29129
29130 wxPyEndAllowThreads(__tstate);
29131 if (PyErr_Occurred()) SWIG_fail;
29132 }
29133 {
29134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29135 }
29136 return resultobj;
29137 fail:
29138 return NULL;
29139 }
29140
29141
29142 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29143 PyObject *resultobj;
29144 wxWindow *arg1 = (wxWindow *) 0 ;
29145 wxRect *arg2 = 0 ;
29146 bool result;
29147 wxRect temp2 ;
29148 PyObject * obj0 = 0 ;
29149 PyObject * obj1 = 0 ;
29150 char *kwnames[] = {
29151 (char *) "self",(char *) "rect", NULL
29152 };
29153
29154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29156 if (SWIG_arg_fail(1)) SWIG_fail;
29157 {
29158 arg2 = &temp2;
29159 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29160 }
29161 {
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29164
29165 wxPyEndAllowThreads(__tstate);
29166 if (PyErr_Occurred()) SWIG_fail;
29167 }
29168 {
29169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29170 }
29171 return resultobj;
29172 fail:
29173 return NULL;
29174 }
29175
29176
29177 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29178 PyObject *resultobj;
29179 wxWindow *arg1 = (wxWindow *) 0 ;
29180 wxVisualAttributes result;
29181 PyObject * obj0 = 0 ;
29182 char *kwnames[] = {
29183 (char *) "self", NULL
29184 };
29185
29186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29188 if (SWIG_arg_fail(1)) SWIG_fail;
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29192
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 {
29197 wxVisualAttributes * resultptr;
29198 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29200 }
29201 return resultobj;
29202 fail:
29203 return NULL;
29204 }
29205
29206
29207 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29208 PyObject *resultobj;
29209 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29210 wxVisualAttributes result;
29211 PyObject * obj0 = 0 ;
29212 char *kwnames[] = {
29213 (char *) "variant", NULL
29214 };
29215
29216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29217 if (obj0) {
29218 {
29219 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29220 if (SWIG_arg_fail(1)) SWIG_fail;
29221 }
29222 }
29223 {
29224 if (!wxPyCheckForApp()) SWIG_fail;
29225 PyThreadState* __tstate = wxPyBeginAllowThreads();
29226 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29227
29228 wxPyEndAllowThreads(__tstate);
29229 if (PyErr_Occurred()) SWIG_fail;
29230 }
29231 {
29232 wxVisualAttributes * resultptr;
29233 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29234 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29235 }
29236 return resultobj;
29237 fail:
29238 return NULL;
29239 }
29240
29241
29242 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29243 PyObject *resultobj;
29244 wxWindow *arg1 = (wxWindow *) 0 ;
29245 wxColour *arg2 = 0 ;
29246 bool result;
29247 wxColour temp2 ;
29248 PyObject * obj0 = 0 ;
29249 PyObject * obj1 = 0 ;
29250 char *kwnames[] = {
29251 (char *) "self",(char *) "colour", NULL
29252 };
29253
29254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29256 if (SWIG_arg_fail(1)) SWIG_fail;
29257 {
29258 arg2 = &temp2;
29259 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29260 }
29261 {
29262 PyThreadState* __tstate = wxPyBeginAllowThreads();
29263 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29264
29265 wxPyEndAllowThreads(__tstate);
29266 if (PyErr_Occurred()) SWIG_fail;
29267 }
29268 {
29269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29270 }
29271 return resultobj;
29272 fail:
29273 return NULL;
29274 }
29275
29276
29277 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29278 PyObject *resultobj;
29279 wxWindow *arg1 = (wxWindow *) 0 ;
29280 wxColour *arg2 = 0 ;
29281 wxColour temp2 ;
29282 PyObject * obj0 = 0 ;
29283 PyObject * obj1 = 0 ;
29284 char *kwnames[] = {
29285 (char *) "self",(char *) "colour", NULL
29286 };
29287
29288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29290 if (SWIG_arg_fail(1)) SWIG_fail;
29291 {
29292 arg2 = &temp2;
29293 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29294 }
29295 {
29296 PyThreadState* __tstate = wxPyBeginAllowThreads();
29297 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29298
29299 wxPyEndAllowThreads(__tstate);
29300 if (PyErr_Occurred()) SWIG_fail;
29301 }
29302 Py_INCREF(Py_None); resultobj = Py_None;
29303 return resultobj;
29304 fail:
29305 return NULL;
29306 }
29307
29308
29309 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29310 PyObject *resultobj;
29311 wxWindow *arg1 = (wxWindow *) 0 ;
29312 wxColour *arg2 = 0 ;
29313 bool result;
29314 wxColour temp2 ;
29315 PyObject * obj0 = 0 ;
29316 PyObject * obj1 = 0 ;
29317 char *kwnames[] = {
29318 (char *) "self",(char *) "colour", NULL
29319 };
29320
29321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29323 if (SWIG_arg_fail(1)) SWIG_fail;
29324 {
29325 arg2 = &temp2;
29326 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29327 }
29328 {
29329 PyThreadState* __tstate = wxPyBeginAllowThreads();
29330 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29331
29332 wxPyEndAllowThreads(__tstate);
29333 if (PyErr_Occurred()) SWIG_fail;
29334 }
29335 {
29336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29337 }
29338 return resultobj;
29339 fail:
29340 return NULL;
29341 }
29342
29343
29344 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29345 PyObject *resultobj;
29346 wxWindow *arg1 = (wxWindow *) 0 ;
29347 wxColour *arg2 = 0 ;
29348 wxColour temp2 ;
29349 PyObject * obj0 = 0 ;
29350 PyObject * obj1 = 0 ;
29351 char *kwnames[] = {
29352 (char *) "self",(char *) "colour", NULL
29353 };
29354
29355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29357 if (SWIG_arg_fail(1)) SWIG_fail;
29358 {
29359 arg2 = &temp2;
29360 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29361 }
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29365
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 Py_INCREF(Py_None); resultobj = Py_None;
29370 return resultobj;
29371 fail:
29372 return NULL;
29373 }
29374
29375
29376 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29377 PyObject *resultobj;
29378 wxWindow *arg1 = (wxWindow *) 0 ;
29379 wxColour result;
29380 PyObject * obj0 = 0 ;
29381 char *kwnames[] = {
29382 (char *) "self", NULL
29383 };
29384
29385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29387 if (SWIG_arg_fail(1)) SWIG_fail;
29388 {
29389 PyThreadState* __tstate = wxPyBeginAllowThreads();
29390 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29391
29392 wxPyEndAllowThreads(__tstate);
29393 if (PyErr_Occurred()) SWIG_fail;
29394 }
29395 {
29396 wxColour * resultptr;
29397 resultptr = new wxColour((wxColour &)(result));
29398 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29399 }
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29407 PyObject *resultobj;
29408 wxWindow *arg1 = (wxWindow *) 0 ;
29409 wxColour result;
29410 PyObject * obj0 = 0 ;
29411 char *kwnames[] = {
29412 (char *) "self", NULL
29413 };
29414
29415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29417 if (SWIG_arg_fail(1)) SWIG_fail;
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 result = ((wxWindow const *)arg1)->GetForegroundColour();
29421
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 {
29426 wxColour * resultptr;
29427 resultptr = new wxColour((wxColour &)(result));
29428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29429 }
29430 return resultobj;
29431 fail:
29432 return NULL;
29433 }
29434
29435
29436 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29437 PyObject *resultobj;
29438 wxWindow *arg1 = (wxWindow *) 0 ;
29439 wxBackgroundStyle arg2 ;
29440 bool result;
29441 PyObject * obj0 = 0 ;
29442 PyObject * obj1 = 0 ;
29443 char *kwnames[] = {
29444 (char *) "self",(char *) "style", NULL
29445 };
29446
29447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29449 if (SWIG_arg_fail(1)) SWIG_fail;
29450 {
29451 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29452 if (SWIG_arg_fail(2)) SWIG_fail;
29453 }
29454 {
29455 PyThreadState* __tstate = wxPyBeginAllowThreads();
29456 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29457
29458 wxPyEndAllowThreads(__tstate);
29459 if (PyErr_Occurred()) SWIG_fail;
29460 }
29461 {
29462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29463 }
29464 return resultobj;
29465 fail:
29466 return NULL;
29467 }
29468
29469
29470 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29471 PyObject *resultobj;
29472 wxWindow *arg1 = (wxWindow *) 0 ;
29473 wxBackgroundStyle result;
29474 PyObject * obj0 = 0 ;
29475 char *kwnames[] = {
29476 (char *) "self", NULL
29477 };
29478
29479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29481 if (SWIG_arg_fail(1)) SWIG_fail;
29482 {
29483 PyThreadState* __tstate = wxPyBeginAllowThreads();
29484 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29485
29486 wxPyEndAllowThreads(__tstate);
29487 if (PyErr_Occurred()) SWIG_fail;
29488 }
29489 resultobj = SWIG_From_int((result));
29490 return resultobj;
29491 fail:
29492 return NULL;
29493 }
29494
29495
29496 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29497 PyObject *resultobj;
29498 wxWindow *arg1 = (wxWindow *) 0 ;
29499 bool result;
29500 PyObject * obj0 = 0 ;
29501 char *kwnames[] = {
29502 (char *) "self", NULL
29503 };
29504
29505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29507 if (SWIG_arg_fail(1)) SWIG_fail;
29508 {
29509 PyThreadState* __tstate = wxPyBeginAllowThreads();
29510 result = (bool)(arg1)->HasTransparentBackground();
29511
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 {
29516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29517 }
29518 return resultobj;
29519 fail:
29520 return NULL;
29521 }
29522
29523
29524 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29525 PyObject *resultobj;
29526 wxWindow *arg1 = (wxWindow *) 0 ;
29527 wxCursor *arg2 = 0 ;
29528 bool result;
29529 PyObject * obj0 = 0 ;
29530 PyObject * obj1 = 0 ;
29531 char *kwnames[] = {
29532 (char *) "self",(char *) "cursor", NULL
29533 };
29534
29535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29537 if (SWIG_arg_fail(1)) SWIG_fail;
29538 {
29539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29540 if (SWIG_arg_fail(2)) SWIG_fail;
29541 if (arg2 == NULL) {
29542 SWIG_null_ref("wxCursor");
29543 }
29544 if (SWIG_arg_fail(2)) SWIG_fail;
29545 }
29546 {
29547 PyThreadState* __tstate = wxPyBeginAllowThreads();
29548 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29549
29550 wxPyEndAllowThreads(__tstate);
29551 if (PyErr_Occurred()) SWIG_fail;
29552 }
29553 {
29554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29555 }
29556 return resultobj;
29557 fail:
29558 return NULL;
29559 }
29560
29561
29562 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29563 PyObject *resultobj;
29564 wxWindow *arg1 = (wxWindow *) 0 ;
29565 wxCursor result;
29566 PyObject * obj0 = 0 ;
29567 char *kwnames[] = {
29568 (char *) "self", NULL
29569 };
29570
29571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29573 if (SWIG_arg_fail(1)) SWIG_fail;
29574 {
29575 PyThreadState* __tstate = wxPyBeginAllowThreads();
29576 result = (arg1)->GetCursor();
29577
29578 wxPyEndAllowThreads(__tstate);
29579 if (PyErr_Occurred()) SWIG_fail;
29580 }
29581 {
29582 wxCursor * resultptr;
29583 resultptr = new wxCursor((wxCursor &)(result));
29584 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29585 }
29586 return resultobj;
29587 fail:
29588 return NULL;
29589 }
29590
29591
29592 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29593 PyObject *resultobj;
29594 wxWindow *arg1 = (wxWindow *) 0 ;
29595 wxFont *arg2 = 0 ;
29596 bool result;
29597 PyObject * obj0 = 0 ;
29598 PyObject * obj1 = 0 ;
29599 char *kwnames[] = {
29600 (char *) "self",(char *) "font", NULL
29601 };
29602
29603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29605 if (SWIG_arg_fail(1)) SWIG_fail;
29606 {
29607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29608 if (SWIG_arg_fail(2)) SWIG_fail;
29609 if (arg2 == NULL) {
29610 SWIG_null_ref("wxFont");
29611 }
29612 if (SWIG_arg_fail(2)) SWIG_fail;
29613 }
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29617
29618 wxPyEndAllowThreads(__tstate);
29619 if (PyErr_Occurred()) SWIG_fail;
29620 }
29621 {
29622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29623 }
29624 return resultobj;
29625 fail:
29626 return NULL;
29627 }
29628
29629
29630 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29631 PyObject *resultobj;
29632 wxWindow *arg1 = (wxWindow *) 0 ;
29633 wxFont *arg2 = 0 ;
29634 PyObject * obj0 = 0 ;
29635 PyObject * obj1 = 0 ;
29636 char *kwnames[] = {
29637 (char *) "self",(char *) "font", NULL
29638 };
29639
29640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29642 if (SWIG_arg_fail(1)) SWIG_fail;
29643 {
29644 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29645 if (SWIG_arg_fail(2)) SWIG_fail;
29646 if (arg2 == NULL) {
29647 SWIG_null_ref("wxFont");
29648 }
29649 if (SWIG_arg_fail(2)) SWIG_fail;
29650 }
29651 {
29652 PyThreadState* __tstate = wxPyBeginAllowThreads();
29653 (arg1)->SetOwnFont((wxFont const &)*arg2);
29654
29655 wxPyEndAllowThreads(__tstate);
29656 if (PyErr_Occurred()) SWIG_fail;
29657 }
29658 Py_INCREF(Py_None); resultobj = Py_None;
29659 return resultobj;
29660 fail:
29661 return NULL;
29662 }
29663
29664
29665 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29666 PyObject *resultobj;
29667 wxWindow *arg1 = (wxWindow *) 0 ;
29668 wxFont result;
29669 PyObject * obj0 = 0 ;
29670 char *kwnames[] = {
29671 (char *) "self", NULL
29672 };
29673
29674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29676 if (SWIG_arg_fail(1)) SWIG_fail;
29677 {
29678 PyThreadState* __tstate = wxPyBeginAllowThreads();
29679 result = (arg1)->GetFont();
29680
29681 wxPyEndAllowThreads(__tstate);
29682 if (PyErr_Occurred()) SWIG_fail;
29683 }
29684 {
29685 wxFont * resultptr;
29686 resultptr = new wxFont((wxFont &)(result));
29687 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29688 }
29689 return resultobj;
29690 fail:
29691 return NULL;
29692 }
29693
29694
29695 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29696 PyObject *resultobj;
29697 wxWindow *arg1 = (wxWindow *) 0 ;
29698 wxCaret *arg2 = (wxCaret *) 0 ;
29699 PyObject * obj0 = 0 ;
29700 PyObject * obj1 = 0 ;
29701 char *kwnames[] = {
29702 (char *) "self",(char *) "caret", NULL
29703 };
29704
29705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29707 if (SWIG_arg_fail(1)) SWIG_fail;
29708 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29709 if (SWIG_arg_fail(2)) SWIG_fail;
29710 {
29711 PyThreadState* __tstate = wxPyBeginAllowThreads();
29712 (arg1)->SetCaret(arg2);
29713
29714 wxPyEndAllowThreads(__tstate);
29715 if (PyErr_Occurred()) SWIG_fail;
29716 }
29717 Py_INCREF(Py_None); resultobj = Py_None;
29718 return resultobj;
29719 fail:
29720 return NULL;
29721 }
29722
29723
29724 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29725 PyObject *resultobj;
29726 wxWindow *arg1 = (wxWindow *) 0 ;
29727 wxCaret *result;
29728 PyObject * obj0 = 0 ;
29729 char *kwnames[] = {
29730 (char *) "self", NULL
29731 };
29732
29733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29735 if (SWIG_arg_fail(1)) SWIG_fail;
29736 {
29737 PyThreadState* __tstate = wxPyBeginAllowThreads();
29738 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29739
29740 wxPyEndAllowThreads(__tstate);
29741 if (PyErr_Occurred()) SWIG_fail;
29742 }
29743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29744 return resultobj;
29745 fail:
29746 return NULL;
29747 }
29748
29749
29750 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29751 PyObject *resultobj;
29752 wxWindow *arg1 = (wxWindow *) 0 ;
29753 int result;
29754 PyObject * obj0 = 0 ;
29755 char *kwnames[] = {
29756 (char *) "self", NULL
29757 };
29758
29759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29761 if (SWIG_arg_fail(1)) SWIG_fail;
29762 {
29763 PyThreadState* __tstate = wxPyBeginAllowThreads();
29764 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29765
29766 wxPyEndAllowThreads(__tstate);
29767 if (PyErr_Occurred()) SWIG_fail;
29768 }
29769 {
29770 resultobj = SWIG_From_int((int)(result));
29771 }
29772 return resultobj;
29773 fail:
29774 return NULL;
29775 }
29776
29777
29778 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29779 PyObject *resultobj;
29780 wxWindow *arg1 = (wxWindow *) 0 ;
29781 int result;
29782 PyObject * obj0 = 0 ;
29783 char *kwnames[] = {
29784 (char *) "self", NULL
29785 };
29786
29787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29789 if (SWIG_arg_fail(1)) SWIG_fail;
29790 {
29791 PyThreadState* __tstate = wxPyBeginAllowThreads();
29792 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29793
29794 wxPyEndAllowThreads(__tstate);
29795 if (PyErr_Occurred()) SWIG_fail;
29796 }
29797 {
29798 resultobj = SWIG_From_int((int)(result));
29799 }
29800 return resultobj;
29801 fail:
29802 return NULL;
29803 }
29804
29805
29806 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29807 PyObject *resultobj;
29808 wxWindow *arg1 = (wxWindow *) 0 ;
29809 wxString *arg2 = 0 ;
29810 int *arg3 = (int *) 0 ;
29811 int *arg4 = (int *) 0 ;
29812 bool temp2 = false ;
29813 int temp3 ;
29814 int res3 = 0 ;
29815 int temp4 ;
29816 int res4 = 0 ;
29817 PyObject * obj0 = 0 ;
29818 PyObject * obj1 = 0 ;
29819 char *kwnames[] = {
29820 (char *) "self",(char *) "string", NULL
29821 };
29822
29823 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29824 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29827 if (SWIG_arg_fail(1)) SWIG_fail;
29828 {
29829 arg2 = wxString_in_helper(obj1);
29830 if (arg2 == NULL) SWIG_fail;
29831 temp2 = true;
29832 }
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29836
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 Py_INCREF(Py_None); resultobj = Py_None;
29841 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29842 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29843 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29844 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29845 {
29846 if (temp2)
29847 delete arg2;
29848 }
29849 return resultobj;
29850 fail:
29851 {
29852 if (temp2)
29853 delete arg2;
29854 }
29855 return NULL;
29856 }
29857
29858
29859 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29860 PyObject *resultobj;
29861 wxWindow *arg1 = (wxWindow *) 0 ;
29862 wxString *arg2 = 0 ;
29863 int *arg3 = (int *) 0 ;
29864 int *arg4 = (int *) 0 ;
29865 int *arg5 = (int *) 0 ;
29866 int *arg6 = (int *) 0 ;
29867 wxFont *arg7 = (wxFont *) NULL ;
29868 bool temp2 = false ;
29869 int temp3 ;
29870 int res3 = 0 ;
29871 int temp4 ;
29872 int res4 = 0 ;
29873 int temp5 ;
29874 int res5 = 0 ;
29875 int temp6 ;
29876 int res6 = 0 ;
29877 PyObject * obj0 = 0 ;
29878 PyObject * obj1 = 0 ;
29879 PyObject * obj2 = 0 ;
29880 char *kwnames[] = {
29881 (char *) "self",(char *) "string",(char *) "font", NULL
29882 };
29883
29884 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29885 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29886 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29887 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29890 if (SWIG_arg_fail(1)) SWIG_fail;
29891 {
29892 arg2 = wxString_in_helper(obj1);
29893 if (arg2 == NULL) SWIG_fail;
29894 temp2 = true;
29895 }
29896 if (obj2) {
29897 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29898 if (SWIG_arg_fail(7)) SWIG_fail;
29899 }
29900 {
29901 PyThreadState* __tstate = wxPyBeginAllowThreads();
29902 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29903
29904 wxPyEndAllowThreads(__tstate);
29905 if (PyErr_Occurred()) SWIG_fail;
29906 }
29907 Py_INCREF(Py_None); resultobj = Py_None;
29908 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29909 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29910 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29911 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29912 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29913 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29914 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29915 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29916 {
29917 if (temp2)
29918 delete arg2;
29919 }
29920 return resultobj;
29921 fail:
29922 {
29923 if (temp2)
29924 delete arg2;
29925 }
29926 return NULL;
29927 }
29928
29929
29930 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29931 PyObject *resultobj;
29932 wxWindow *arg1 = (wxWindow *) 0 ;
29933 int *arg2 = (int *) 0 ;
29934 int *arg3 = (int *) 0 ;
29935 int temp2 ;
29936 int res2 = 0 ;
29937 int temp3 ;
29938 int res3 = 0 ;
29939 PyObject * obj0 = 0 ;
29940 PyObject * obj1 = 0 ;
29941 PyObject * obj2 = 0 ;
29942 char *kwnames[] = {
29943 (char *) "self",(char *) "x",(char *) "y", NULL
29944 };
29945
29946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29948 if (SWIG_arg_fail(1)) SWIG_fail;
29949 {
29950 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29951 temp2 = SWIG_As_int(obj1);
29952 if (SWIG_arg_fail(2)) SWIG_fail;
29953 arg2 = &temp2;
29954 res2 = SWIG_NEWOBJ;
29955 }
29956 }
29957 {
29958 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29959 temp3 = SWIG_As_int(obj2);
29960 if (SWIG_arg_fail(3)) SWIG_fail;
29961 arg3 = &temp3;
29962 res3 = SWIG_NEWOBJ;
29963 }
29964 }
29965 {
29966 PyThreadState* __tstate = wxPyBeginAllowThreads();
29967 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29968
29969 wxPyEndAllowThreads(__tstate);
29970 if (PyErr_Occurred()) SWIG_fail;
29971 }
29972 Py_INCREF(Py_None); resultobj = Py_None;
29973 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29974 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29975 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29976 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29977 return resultobj;
29978 fail:
29979 return NULL;
29980 }
29981
29982
29983 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29984 PyObject *resultobj;
29985 wxWindow *arg1 = (wxWindow *) 0 ;
29986 int *arg2 = (int *) 0 ;
29987 int *arg3 = (int *) 0 ;
29988 int temp2 ;
29989 int res2 = 0 ;
29990 int temp3 ;
29991 int res3 = 0 ;
29992 PyObject * obj0 = 0 ;
29993 PyObject * obj1 = 0 ;
29994 PyObject * obj2 = 0 ;
29995 char *kwnames[] = {
29996 (char *) "self",(char *) "x",(char *) "y", NULL
29997 };
29998
29999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) 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 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30004 temp2 = SWIG_As_int(obj1);
30005 if (SWIG_arg_fail(2)) SWIG_fail;
30006 arg2 = &temp2;
30007 res2 = SWIG_NEWOBJ;
30008 }
30009 }
30010 {
30011 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30012 temp3 = SWIG_As_int(obj2);
30013 if (SWIG_arg_fail(3)) SWIG_fail;
30014 arg3 = &temp3;
30015 res3 = SWIG_NEWOBJ;
30016 }
30017 }
30018 {
30019 PyThreadState* __tstate = wxPyBeginAllowThreads();
30020 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30021
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 Py_INCREF(Py_None); resultobj = Py_None;
30026 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30027 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30028 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30029 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30030 return resultobj;
30031 fail:
30032 return NULL;
30033 }
30034
30035
30036 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30037 PyObject *resultobj;
30038 wxWindow *arg1 = (wxWindow *) 0 ;
30039 wxPoint *arg2 = 0 ;
30040 wxPoint result;
30041 wxPoint temp2 ;
30042 PyObject * obj0 = 0 ;
30043 PyObject * obj1 = 0 ;
30044 char *kwnames[] = {
30045 (char *) "self",(char *) "pt", NULL
30046 };
30047
30048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30050 if (SWIG_arg_fail(1)) SWIG_fail;
30051 {
30052 arg2 = &temp2;
30053 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30054 }
30055 {
30056 PyThreadState* __tstate = wxPyBeginAllowThreads();
30057 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30058
30059 wxPyEndAllowThreads(__tstate);
30060 if (PyErr_Occurred()) SWIG_fail;
30061 }
30062 {
30063 wxPoint * resultptr;
30064 resultptr = new wxPoint((wxPoint &)(result));
30065 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30066 }
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30074 PyObject *resultobj;
30075 wxWindow *arg1 = (wxWindow *) 0 ;
30076 wxPoint *arg2 = 0 ;
30077 wxPoint result;
30078 wxPoint temp2 ;
30079 PyObject * obj0 = 0 ;
30080 PyObject * obj1 = 0 ;
30081 char *kwnames[] = {
30082 (char *) "self",(char *) "pt", NULL
30083 };
30084
30085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",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 = &temp2;
30090 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30091 }
30092 {
30093 PyThreadState* __tstate = wxPyBeginAllowThreads();
30094 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30095
30096 wxPyEndAllowThreads(__tstate);
30097 if (PyErr_Occurred()) SWIG_fail;
30098 }
30099 {
30100 wxPoint * resultptr;
30101 resultptr = new wxPoint((wxPoint &)(result));
30102 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30103 }
30104 return resultobj;
30105 fail:
30106 return NULL;
30107 }
30108
30109
30110 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30111 PyObject *resultobj;
30112 wxWindow *arg1 = (wxWindow *) 0 ;
30113 int arg2 ;
30114 int arg3 ;
30115 wxHitTest result;
30116 PyObject * obj0 = 0 ;
30117 PyObject * obj1 = 0 ;
30118 PyObject * obj2 = 0 ;
30119 char *kwnames[] = {
30120 (char *) "self",(char *) "x",(char *) "y", NULL
30121 };
30122
30123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30125 if (SWIG_arg_fail(1)) SWIG_fail;
30126 {
30127 arg2 = (int)(SWIG_As_int(obj1));
30128 if (SWIG_arg_fail(2)) SWIG_fail;
30129 }
30130 {
30131 arg3 = (int)(SWIG_As_int(obj2));
30132 if (SWIG_arg_fail(3)) SWIG_fail;
30133 }
30134 {
30135 PyThreadState* __tstate = wxPyBeginAllowThreads();
30136 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30137
30138 wxPyEndAllowThreads(__tstate);
30139 if (PyErr_Occurred()) SWIG_fail;
30140 }
30141 resultobj = SWIG_From_int((result));
30142 return resultobj;
30143 fail:
30144 return NULL;
30145 }
30146
30147
30148 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30149 PyObject *resultobj;
30150 wxWindow *arg1 = (wxWindow *) 0 ;
30151 wxPoint *arg2 = 0 ;
30152 wxHitTest result;
30153 wxPoint temp2 ;
30154 PyObject * obj0 = 0 ;
30155 PyObject * obj1 = 0 ;
30156 char *kwnames[] = {
30157 (char *) "self",(char *) "pt", NULL
30158 };
30159
30160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30162 if (SWIG_arg_fail(1)) SWIG_fail;
30163 {
30164 arg2 = &temp2;
30165 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30166 }
30167 {
30168 PyThreadState* __tstate = wxPyBeginAllowThreads();
30169 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30170
30171 wxPyEndAllowThreads(__tstate);
30172 if (PyErr_Occurred()) SWIG_fail;
30173 }
30174 resultobj = SWIG_From_int((result));
30175 return resultobj;
30176 fail:
30177 return NULL;
30178 }
30179
30180
30181 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30182 PyObject *resultobj;
30183 wxWindow *arg1 = (wxWindow *) 0 ;
30184 long arg2 ;
30185 wxBorder result;
30186 PyObject * obj0 = 0 ;
30187 PyObject * obj1 = 0 ;
30188
30189 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30191 if (SWIG_arg_fail(1)) SWIG_fail;
30192 {
30193 arg2 = (long)(SWIG_As_long(obj1));
30194 if (SWIG_arg_fail(2)) SWIG_fail;
30195 }
30196 {
30197 PyThreadState* __tstate = wxPyBeginAllowThreads();
30198 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30199
30200 wxPyEndAllowThreads(__tstate);
30201 if (PyErr_Occurred()) SWIG_fail;
30202 }
30203 resultobj = SWIG_From_int((result));
30204 return resultobj;
30205 fail:
30206 return NULL;
30207 }
30208
30209
30210 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30211 PyObject *resultobj;
30212 wxWindow *arg1 = (wxWindow *) 0 ;
30213 wxBorder result;
30214 PyObject * obj0 = 0 ;
30215
30216 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30218 if (SWIG_arg_fail(1)) SWIG_fail;
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30222
30223 wxPyEndAllowThreads(__tstate);
30224 if (PyErr_Occurred()) SWIG_fail;
30225 }
30226 resultobj = SWIG_From_int((result));
30227 return resultobj;
30228 fail:
30229 return NULL;
30230 }
30231
30232
30233 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30234 int argc;
30235 PyObject *argv[3];
30236 int ii;
30237
30238 argc = PyObject_Length(args);
30239 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30240 argv[ii] = PyTuple_GetItem(args,ii);
30241 }
30242 if (argc == 1) {
30243 int _v;
30244 {
30245 void *ptr;
30246 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30247 _v = 0;
30248 PyErr_Clear();
30249 } else {
30250 _v = 1;
30251 }
30252 }
30253 if (_v) {
30254 return _wrap_Window_GetBorder__SWIG_1(self,args);
30255 }
30256 }
30257 if (argc == 2) {
30258 int _v;
30259 {
30260 void *ptr;
30261 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30262 _v = 0;
30263 PyErr_Clear();
30264 } else {
30265 _v = 1;
30266 }
30267 }
30268 if (_v) {
30269 _v = SWIG_Check_long(argv[1]);
30270 if (_v) {
30271 return _wrap_Window_GetBorder__SWIG_0(self,args);
30272 }
30273 }
30274 }
30275
30276 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30277 return NULL;
30278 }
30279
30280
30281 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30282 PyObject *resultobj;
30283 wxWindow *arg1 = (wxWindow *) 0 ;
30284 long arg2 = (long) wxUPDATE_UI_NONE ;
30285 PyObject * obj0 = 0 ;
30286 PyObject * obj1 = 0 ;
30287 char *kwnames[] = {
30288 (char *) "self",(char *) "flags", NULL
30289 };
30290
30291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30293 if (SWIG_arg_fail(1)) SWIG_fail;
30294 if (obj1) {
30295 {
30296 arg2 = (long)(SWIG_As_long(obj1));
30297 if (SWIG_arg_fail(2)) SWIG_fail;
30298 }
30299 }
30300 {
30301 PyThreadState* __tstate = wxPyBeginAllowThreads();
30302 (arg1)->UpdateWindowUI(arg2);
30303
30304 wxPyEndAllowThreads(__tstate);
30305 if (PyErr_Occurred()) SWIG_fail;
30306 }
30307 Py_INCREF(Py_None); resultobj = Py_None;
30308 return resultobj;
30309 fail:
30310 return NULL;
30311 }
30312
30313
30314 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30315 PyObject *resultobj;
30316 wxWindow *arg1 = (wxWindow *) 0 ;
30317 wxMenu *arg2 = (wxMenu *) 0 ;
30318 int arg3 = (int) -1 ;
30319 int arg4 = (int) -1 ;
30320 bool result;
30321 PyObject * obj0 = 0 ;
30322 PyObject * obj1 = 0 ;
30323 PyObject * obj2 = 0 ;
30324 PyObject * obj3 = 0 ;
30325 char *kwnames[] = {
30326 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30327 };
30328
30329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30331 if (SWIG_arg_fail(1)) SWIG_fail;
30332 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30333 if (SWIG_arg_fail(2)) SWIG_fail;
30334 if (obj2) {
30335 {
30336 arg3 = (int)(SWIG_As_int(obj2));
30337 if (SWIG_arg_fail(3)) SWIG_fail;
30338 }
30339 }
30340 if (obj3) {
30341 {
30342 arg4 = (int)(SWIG_As_int(obj3));
30343 if (SWIG_arg_fail(4)) SWIG_fail;
30344 }
30345 }
30346 {
30347 PyThreadState* __tstate = wxPyBeginAllowThreads();
30348 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30349
30350 wxPyEndAllowThreads(__tstate);
30351 if (PyErr_Occurred()) SWIG_fail;
30352 }
30353 {
30354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30355 }
30356 return resultobj;
30357 fail:
30358 return NULL;
30359 }
30360
30361
30362 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30363 PyObject *resultobj;
30364 wxWindow *arg1 = (wxWindow *) 0 ;
30365 wxMenu *arg2 = (wxMenu *) 0 ;
30366 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30367 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30368 bool result;
30369 wxPoint temp3 ;
30370 PyObject * obj0 = 0 ;
30371 PyObject * obj1 = 0 ;
30372 PyObject * obj2 = 0 ;
30373 char *kwnames[] = {
30374 (char *) "self",(char *) "menu",(char *) "pos", NULL
30375 };
30376
30377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30379 if (SWIG_arg_fail(1)) SWIG_fail;
30380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30381 if (SWIG_arg_fail(2)) SWIG_fail;
30382 if (obj2) {
30383 {
30384 arg3 = &temp3;
30385 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30386 }
30387 }
30388 {
30389 PyThreadState* __tstate = wxPyBeginAllowThreads();
30390 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30391
30392 wxPyEndAllowThreads(__tstate);
30393 if (PyErr_Occurred()) SWIG_fail;
30394 }
30395 {
30396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30397 }
30398 return resultobj;
30399 fail:
30400 return NULL;
30401 }
30402
30403
30404 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30405 PyObject *resultobj;
30406 wxWindow *arg1 = (wxWindow *) 0 ;
30407 long result;
30408 PyObject * obj0 = 0 ;
30409 char *kwnames[] = {
30410 (char *) "self", NULL
30411 };
30412
30413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30415 if (SWIG_arg_fail(1)) SWIG_fail;
30416 {
30417 PyThreadState* __tstate = wxPyBeginAllowThreads();
30418 result = (long)wxWindow_GetHandle(arg1);
30419
30420 wxPyEndAllowThreads(__tstate);
30421 if (PyErr_Occurred()) SWIG_fail;
30422 }
30423 {
30424 resultobj = SWIG_From_long((long)(result));
30425 }
30426 return resultobj;
30427 fail:
30428 return NULL;
30429 }
30430
30431
30432 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30433 PyObject *resultobj;
30434 wxWindow *arg1 = (wxWindow *) 0 ;
30435 long arg2 ;
30436 PyObject * obj0 = 0 ;
30437 PyObject * obj1 = 0 ;
30438 char *kwnames[] = {
30439 (char *) "self",(char *) "handle", NULL
30440 };
30441
30442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30444 if (SWIG_arg_fail(1)) SWIG_fail;
30445 {
30446 arg2 = (long)(SWIG_As_long(obj1));
30447 if (SWIG_arg_fail(2)) SWIG_fail;
30448 }
30449 {
30450 PyThreadState* __tstate = wxPyBeginAllowThreads();
30451 wxWindow_AssociateHandle(arg1,arg2);
30452
30453 wxPyEndAllowThreads(__tstate);
30454 if (PyErr_Occurred()) SWIG_fail;
30455 }
30456 Py_INCREF(Py_None); resultobj = Py_None;
30457 return resultobj;
30458 fail:
30459 return NULL;
30460 }
30461
30462
30463 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30464 PyObject *resultobj;
30465 wxWindow *arg1 = (wxWindow *) 0 ;
30466 PyObject * obj0 = 0 ;
30467 char *kwnames[] = {
30468 (char *) "self", NULL
30469 };
30470
30471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30473 if (SWIG_arg_fail(1)) SWIG_fail;
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 (arg1)->DissociateHandle();
30477
30478 wxPyEndAllowThreads(__tstate);
30479 if (PyErr_Occurred()) SWIG_fail;
30480 }
30481 Py_INCREF(Py_None); resultobj = Py_None;
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj;
30490 wxWindow *arg1 = (wxWindow *) 0 ;
30491 wxPaintEvent *arg2 = 0 ;
30492 PyObject * obj0 = 0 ;
30493 PyObject * obj1 = 0 ;
30494 char *kwnames[] = {
30495 (char *) "self",(char *) "event", NULL
30496 };
30497
30498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30500 if (SWIG_arg_fail(1)) SWIG_fail;
30501 {
30502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30503 if (SWIG_arg_fail(2)) SWIG_fail;
30504 if (arg2 == NULL) {
30505 SWIG_null_ref("wxPaintEvent");
30506 }
30507 if (SWIG_arg_fail(2)) SWIG_fail;
30508 }
30509 {
30510 PyThreadState* __tstate = wxPyBeginAllowThreads();
30511 (arg1)->OnPaint(*arg2);
30512
30513 wxPyEndAllowThreads(__tstate);
30514 if (PyErr_Occurred()) SWIG_fail;
30515 }
30516 Py_INCREF(Py_None); resultobj = Py_None;
30517 return resultobj;
30518 fail:
30519 return NULL;
30520 }
30521
30522
30523 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30524 PyObject *resultobj;
30525 wxWindow *arg1 = (wxWindow *) 0 ;
30526 int arg2 ;
30527 bool result;
30528 PyObject * obj0 = 0 ;
30529 PyObject * obj1 = 0 ;
30530 char *kwnames[] = {
30531 (char *) "self",(char *) "orient", NULL
30532 };
30533
30534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30536 if (SWIG_arg_fail(1)) SWIG_fail;
30537 {
30538 arg2 = (int)(SWIG_As_int(obj1));
30539 if (SWIG_arg_fail(2)) SWIG_fail;
30540 }
30541 {
30542 PyThreadState* __tstate = wxPyBeginAllowThreads();
30543 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30544
30545 wxPyEndAllowThreads(__tstate);
30546 if (PyErr_Occurred()) SWIG_fail;
30547 }
30548 {
30549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30550 }
30551 return resultobj;
30552 fail:
30553 return NULL;
30554 }
30555
30556
30557 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30558 PyObject *resultobj;
30559 wxWindow *arg1 = (wxWindow *) 0 ;
30560 int arg2 ;
30561 int arg3 ;
30562 int arg4 ;
30563 int arg5 ;
30564 bool arg6 = (bool) true ;
30565 PyObject * obj0 = 0 ;
30566 PyObject * obj1 = 0 ;
30567 PyObject * obj2 = 0 ;
30568 PyObject * obj3 = 0 ;
30569 PyObject * obj4 = 0 ;
30570 PyObject * obj5 = 0 ;
30571 char *kwnames[] = {
30572 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30573 };
30574
30575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30577 if (SWIG_arg_fail(1)) SWIG_fail;
30578 {
30579 arg2 = (int)(SWIG_As_int(obj1));
30580 if (SWIG_arg_fail(2)) SWIG_fail;
30581 }
30582 {
30583 arg3 = (int)(SWIG_As_int(obj2));
30584 if (SWIG_arg_fail(3)) SWIG_fail;
30585 }
30586 {
30587 arg4 = (int)(SWIG_As_int(obj3));
30588 if (SWIG_arg_fail(4)) SWIG_fail;
30589 }
30590 {
30591 arg5 = (int)(SWIG_As_int(obj4));
30592 if (SWIG_arg_fail(5)) SWIG_fail;
30593 }
30594 if (obj5) {
30595 {
30596 arg6 = (bool)(SWIG_As_bool(obj5));
30597 if (SWIG_arg_fail(6)) SWIG_fail;
30598 }
30599 }
30600 {
30601 PyThreadState* __tstate = wxPyBeginAllowThreads();
30602 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30603
30604 wxPyEndAllowThreads(__tstate);
30605 if (PyErr_Occurred()) SWIG_fail;
30606 }
30607 Py_INCREF(Py_None); resultobj = Py_None;
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30615 PyObject *resultobj;
30616 wxWindow *arg1 = (wxWindow *) 0 ;
30617 int arg2 ;
30618 int arg3 ;
30619 bool arg4 = (bool) true ;
30620 PyObject * obj0 = 0 ;
30621 PyObject * obj1 = 0 ;
30622 PyObject * obj2 = 0 ;
30623 PyObject * obj3 = 0 ;
30624 char *kwnames[] = {
30625 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30626 };
30627
30628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30630 if (SWIG_arg_fail(1)) SWIG_fail;
30631 {
30632 arg2 = (int)(SWIG_As_int(obj1));
30633 if (SWIG_arg_fail(2)) SWIG_fail;
30634 }
30635 {
30636 arg3 = (int)(SWIG_As_int(obj2));
30637 if (SWIG_arg_fail(3)) SWIG_fail;
30638 }
30639 if (obj3) {
30640 {
30641 arg4 = (bool)(SWIG_As_bool(obj3));
30642 if (SWIG_arg_fail(4)) SWIG_fail;
30643 }
30644 }
30645 {
30646 PyThreadState* __tstate = wxPyBeginAllowThreads();
30647 (arg1)->SetScrollPos(arg2,arg3,arg4);
30648
30649 wxPyEndAllowThreads(__tstate);
30650 if (PyErr_Occurred()) SWIG_fail;
30651 }
30652 Py_INCREF(Py_None); resultobj = Py_None;
30653 return resultobj;
30654 fail:
30655 return NULL;
30656 }
30657
30658
30659 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30660 PyObject *resultobj;
30661 wxWindow *arg1 = (wxWindow *) 0 ;
30662 int arg2 ;
30663 int result;
30664 PyObject * obj0 = 0 ;
30665 PyObject * obj1 = 0 ;
30666 char *kwnames[] = {
30667 (char *) "self",(char *) "orientation", NULL
30668 };
30669
30670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30672 if (SWIG_arg_fail(1)) SWIG_fail;
30673 {
30674 arg2 = (int)(SWIG_As_int(obj1));
30675 if (SWIG_arg_fail(2)) SWIG_fail;
30676 }
30677 {
30678 PyThreadState* __tstate = wxPyBeginAllowThreads();
30679 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30680
30681 wxPyEndAllowThreads(__tstate);
30682 if (PyErr_Occurred()) SWIG_fail;
30683 }
30684 {
30685 resultobj = SWIG_From_int((int)(result));
30686 }
30687 return resultobj;
30688 fail:
30689 return NULL;
30690 }
30691
30692
30693 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30694 PyObject *resultobj;
30695 wxWindow *arg1 = (wxWindow *) 0 ;
30696 int arg2 ;
30697 int result;
30698 PyObject * obj0 = 0 ;
30699 PyObject * obj1 = 0 ;
30700 char *kwnames[] = {
30701 (char *) "self",(char *) "orientation", NULL
30702 };
30703
30704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30706 if (SWIG_arg_fail(1)) SWIG_fail;
30707 {
30708 arg2 = (int)(SWIG_As_int(obj1));
30709 if (SWIG_arg_fail(2)) SWIG_fail;
30710 }
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30714
30715 wxPyEndAllowThreads(__tstate);
30716 if (PyErr_Occurred()) SWIG_fail;
30717 }
30718 {
30719 resultobj = SWIG_From_int((int)(result));
30720 }
30721 return resultobj;
30722 fail:
30723 return NULL;
30724 }
30725
30726
30727 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30728 PyObject *resultobj;
30729 wxWindow *arg1 = (wxWindow *) 0 ;
30730 int arg2 ;
30731 int result;
30732 PyObject * obj0 = 0 ;
30733 PyObject * obj1 = 0 ;
30734 char *kwnames[] = {
30735 (char *) "self",(char *) "orientation", NULL
30736 };
30737
30738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30740 if (SWIG_arg_fail(1)) SWIG_fail;
30741 {
30742 arg2 = (int)(SWIG_As_int(obj1));
30743 if (SWIG_arg_fail(2)) SWIG_fail;
30744 }
30745 {
30746 PyThreadState* __tstate = wxPyBeginAllowThreads();
30747 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30748
30749 wxPyEndAllowThreads(__tstate);
30750 if (PyErr_Occurred()) SWIG_fail;
30751 }
30752 {
30753 resultobj = SWIG_From_int((int)(result));
30754 }
30755 return resultobj;
30756 fail:
30757 return NULL;
30758 }
30759
30760
30761 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30762 PyObject *resultobj;
30763 wxWindow *arg1 = (wxWindow *) 0 ;
30764 int arg2 ;
30765 int arg3 ;
30766 wxRect *arg4 = (wxRect *) NULL ;
30767 PyObject * obj0 = 0 ;
30768 PyObject * obj1 = 0 ;
30769 PyObject * obj2 = 0 ;
30770 PyObject * obj3 = 0 ;
30771 char *kwnames[] = {
30772 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30773 };
30774
30775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30777 if (SWIG_arg_fail(1)) SWIG_fail;
30778 {
30779 arg2 = (int)(SWIG_As_int(obj1));
30780 if (SWIG_arg_fail(2)) SWIG_fail;
30781 }
30782 {
30783 arg3 = (int)(SWIG_As_int(obj2));
30784 if (SWIG_arg_fail(3)) SWIG_fail;
30785 }
30786 if (obj3) {
30787 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30788 if (SWIG_arg_fail(4)) SWIG_fail;
30789 }
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30793
30794 wxPyEndAllowThreads(__tstate);
30795 if (PyErr_Occurred()) SWIG_fail;
30796 }
30797 Py_INCREF(Py_None); resultobj = Py_None;
30798 return resultobj;
30799 fail:
30800 return NULL;
30801 }
30802
30803
30804 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30805 PyObject *resultobj;
30806 wxWindow *arg1 = (wxWindow *) 0 ;
30807 int arg2 ;
30808 bool result;
30809 PyObject * obj0 = 0 ;
30810 PyObject * obj1 = 0 ;
30811 char *kwnames[] = {
30812 (char *) "self",(char *) "lines", NULL
30813 };
30814
30815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30817 if (SWIG_arg_fail(1)) SWIG_fail;
30818 {
30819 arg2 = (int)(SWIG_As_int(obj1));
30820 if (SWIG_arg_fail(2)) SWIG_fail;
30821 }
30822 {
30823 PyThreadState* __tstate = wxPyBeginAllowThreads();
30824 result = (bool)(arg1)->ScrollLines(arg2);
30825
30826 wxPyEndAllowThreads(__tstate);
30827 if (PyErr_Occurred()) SWIG_fail;
30828 }
30829 {
30830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30831 }
30832 return resultobj;
30833 fail:
30834 return NULL;
30835 }
30836
30837
30838 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30839 PyObject *resultobj;
30840 wxWindow *arg1 = (wxWindow *) 0 ;
30841 int arg2 ;
30842 bool result;
30843 PyObject * obj0 = 0 ;
30844 PyObject * obj1 = 0 ;
30845 char *kwnames[] = {
30846 (char *) "self",(char *) "pages", NULL
30847 };
30848
30849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30851 if (SWIG_arg_fail(1)) SWIG_fail;
30852 {
30853 arg2 = (int)(SWIG_As_int(obj1));
30854 if (SWIG_arg_fail(2)) SWIG_fail;
30855 }
30856 {
30857 PyThreadState* __tstate = wxPyBeginAllowThreads();
30858 result = (bool)(arg1)->ScrollPages(arg2);
30859
30860 wxPyEndAllowThreads(__tstate);
30861 if (PyErr_Occurred()) SWIG_fail;
30862 }
30863 {
30864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30865 }
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj;
30874 wxWindow *arg1 = (wxWindow *) 0 ;
30875 bool result;
30876 PyObject * obj0 = 0 ;
30877 char *kwnames[] = {
30878 (char *) "self", NULL
30879 };
30880
30881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30883 if (SWIG_arg_fail(1)) SWIG_fail;
30884 {
30885 PyThreadState* __tstate = wxPyBeginAllowThreads();
30886 result = (bool)(arg1)->LineUp();
30887
30888 wxPyEndAllowThreads(__tstate);
30889 if (PyErr_Occurred()) SWIG_fail;
30890 }
30891 {
30892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30893 }
30894 return resultobj;
30895 fail:
30896 return NULL;
30897 }
30898
30899
30900 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30901 PyObject *resultobj;
30902 wxWindow *arg1 = (wxWindow *) 0 ;
30903 bool result;
30904 PyObject * obj0 = 0 ;
30905 char *kwnames[] = {
30906 (char *) "self", NULL
30907 };
30908
30909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30911 if (SWIG_arg_fail(1)) SWIG_fail;
30912 {
30913 PyThreadState* __tstate = wxPyBeginAllowThreads();
30914 result = (bool)(arg1)->LineDown();
30915
30916 wxPyEndAllowThreads(__tstate);
30917 if (PyErr_Occurred()) SWIG_fail;
30918 }
30919 {
30920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30921 }
30922 return resultobj;
30923 fail:
30924 return NULL;
30925 }
30926
30927
30928 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30929 PyObject *resultobj;
30930 wxWindow *arg1 = (wxWindow *) 0 ;
30931 bool result;
30932 PyObject * obj0 = 0 ;
30933 char *kwnames[] = {
30934 (char *) "self", NULL
30935 };
30936
30937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30939 if (SWIG_arg_fail(1)) SWIG_fail;
30940 {
30941 PyThreadState* __tstate = wxPyBeginAllowThreads();
30942 result = (bool)(arg1)->PageUp();
30943
30944 wxPyEndAllowThreads(__tstate);
30945 if (PyErr_Occurred()) SWIG_fail;
30946 }
30947 {
30948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30949 }
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 bool result;
30960 PyObject * obj0 = 0 ;
30961 char *kwnames[] = {
30962 (char *) "self", NULL
30963 };
30964
30965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30967 if (SWIG_arg_fail(1)) SWIG_fail;
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 result = (bool)(arg1)->PageDown();
30971
30972 wxPyEndAllowThreads(__tstate);
30973 if (PyErr_Occurred()) SWIG_fail;
30974 }
30975 {
30976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30977 }
30978 return resultobj;
30979 fail:
30980 return NULL;
30981 }
30982
30983
30984 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30985 PyObject *resultobj;
30986 wxWindow *arg1 = (wxWindow *) 0 ;
30987 wxString *arg2 = 0 ;
30988 bool temp2 = false ;
30989 PyObject * obj0 = 0 ;
30990 PyObject * obj1 = 0 ;
30991 char *kwnames[] = {
30992 (char *) "self",(char *) "text", NULL
30993 };
30994
30995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30997 if (SWIG_arg_fail(1)) SWIG_fail;
30998 {
30999 arg2 = wxString_in_helper(obj1);
31000 if (arg2 == NULL) SWIG_fail;
31001 temp2 = true;
31002 }
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 (arg1)->SetHelpText((wxString const &)*arg2);
31006
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 Py_INCREF(Py_None); resultobj = Py_None;
31011 {
31012 if (temp2)
31013 delete arg2;
31014 }
31015 return resultobj;
31016 fail:
31017 {
31018 if (temp2)
31019 delete arg2;
31020 }
31021 return NULL;
31022 }
31023
31024
31025 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31026 PyObject *resultobj;
31027 wxWindow *arg1 = (wxWindow *) 0 ;
31028 wxString *arg2 = 0 ;
31029 bool temp2 = false ;
31030 PyObject * obj0 = 0 ;
31031 PyObject * obj1 = 0 ;
31032 char *kwnames[] = {
31033 (char *) "self",(char *) "text", NULL
31034 };
31035
31036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31038 if (SWIG_arg_fail(1)) SWIG_fail;
31039 {
31040 arg2 = wxString_in_helper(obj1);
31041 if (arg2 == NULL) SWIG_fail;
31042 temp2 = true;
31043 }
31044 {
31045 PyThreadState* __tstate = wxPyBeginAllowThreads();
31046 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31047
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 Py_INCREF(Py_None); resultobj = Py_None;
31052 {
31053 if (temp2)
31054 delete arg2;
31055 }
31056 return resultobj;
31057 fail:
31058 {
31059 if (temp2)
31060 delete arg2;
31061 }
31062 return NULL;
31063 }
31064
31065
31066 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31067 PyObject *resultobj;
31068 wxWindow *arg1 = (wxWindow *) 0 ;
31069 wxString result;
31070 PyObject * obj0 = 0 ;
31071 char *kwnames[] = {
31072 (char *) "self", NULL
31073 };
31074
31075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31077 if (SWIG_arg_fail(1)) SWIG_fail;
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 result = ((wxWindow const *)arg1)->GetHelpText();
31081
31082 wxPyEndAllowThreads(__tstate);
31083 if (PyErr_Occurred()) SWIG_fail;
31084 }
31085 {
31086 #if wxUSE_UNICODE
31087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31088 #else
31089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31090 #endif
31091 }
31092 return resultobj;
31093 fail:
31094 return NULL;
31095 }
31096
31097
31098 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31099 PyObject *resultobj;
31100 wxWindow *arg1 = (wxWindow *) 0 ;
31101 wxString *arg2 = 0 ;
31102 bool temp2 = false ;
31103 PyObject * obj0 = 0 ;
31104 PyObject * obj1 = 0 ;
31105 char *kwnames[] = {
31106 (char *) "self",(char *) "tip", NULL
31107 };
31108
31109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31111 if (SWIG_arg_fail(1)) SWIG_fail;
31112 {
31113 arg2 = wxString_in_helper(obj1);
31114 if (arg2 == NULL) SWIG_fail;
31115 temp2 = true;
31116 }
31117 {
31118 PyThreadState* __tstate = wxPyBeginAllowThreads();
31119 (arg1)->SetToolTip((wxString const &)*arg2);
31120
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 Py_INCREF(Py_None); resultobj = Py_None;
31125 {
31126 if (temp2)
31127 delete arg2;
31128 }
31129 return resultobj;
31130 fail:
31131 {
31132 if (temp2)
31133 delete arg2;
31134 }
31135 return NULL;
31136 }
31137
31138
31139 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31140 PyObject *resultobj;
31141 wxWindow *arg1 = (wxWindow *) 0 ;
31142 wxToolTip *arg2 = (wxToolTip *) 0 ;
31143 PyObject * obj0 = 0 ;
31144 PyObject * obj1 = 0 ;
31145 char *kwnames[] = {
31146 (char *) "self",(char *) "tip", NULL
31147 };
31148
31149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31151 if (SWIG_arg_fail(1)) SWIG_fail;
31152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31153 if (SWIG_arg_fail(2)) SWIG_fail;
31154 {
31155 PyThreadState* __tstate = wxPyBeginAllowThreads();
31156 (arg1)->SetToolTip(arg2);
31157
31158 wxPyEndAllowThreads(__tstate);
31159 if (PyErr_Occurred()) SWIG_fail;
31160 }
31161 Py_INCREF(Py_None); resultobj = Py_None;
31162 return resultobj;
31163 fail:
31164 return NULL;
31165 }
31166
31167
31168 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31169 PyObject *resultobj;
31170 wxWindow *arg1 = (wxWindow *) 0 ;
31171 wxToolTip *result;
31172 PyObject * obj0 = 0 ;
31173 char *kwnames[] = {
31174 (char *) "self", NULL
31175 };
31176
31177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31179 if (SWIG_arg_fail(1)) SWIG_fail;
31180 {
31181 PyThreadState* __tstate = wxPyBeginAllowThreads();
31182 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31183
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 {
31188 resultobj = wxPyMake_wxObject(result, 0);
31189 }
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31197 PyObject *resultobj;
31198 wxWindow *arg1 = (wxWindow *) 0 ;
31199 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31200 PyObject * obj0 = 0 ;
31201 PyObject * obj1 = 0 ;
31202 char *kwnames[] = {
31203 (char *) "self",(char *) "dropTarget", NULL
31204 };
31205
31206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31208 if (SWIG_arg_fail(1)) SWIG_fail;
31209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31210 if (SWIG_arg_fail(2)) SWIG_fail;
31211 {
31212 PyThreadState* __tstate = wxPyBeginAllowThreads();
31213 (arg1)->SetDropTarget(arg2);
31214
31215 wxPyEndAllowThreads(__tstate);
31216 if (PyErr_Occurred()) SWIG_fail;
31217 }
31218 Py_INCREF(Py_None); resultobj = Py_None;
31219 return resultobj;
31220 fail:
31221 return NULL;
31222 }
31223
31224
31225 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31226 PyObject *resultobj;
31227 wxWindow *arg1 = (wxWindow *) 0 ;
31228 wxPyDropTarget *result;
31229 PyObject * obj0 = 0 ;
31230 char *kwnames[] = {
31231 (char *) "self", NULL
31232 };
31233
31234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31236 if (SWIG_arg_fail(1)) SWIG_fail;
31237 {
31238 PyThreadState* __tstate = wxPyBeginAllowThreads();
31239 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31240
31241 wxPyEndAllowThreads(__tstate);
31242 if (PyErr_Occurred()) SWIG_fail;
31243 }
31244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31245 return resultobj;
31246 fail:
31247 return NULL;
31248 }
31249
31250
31251 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31252 PyObject *resultobj;
31253 wxWindow *arg1 = (wxWindow *) 0 ;
31254 bool arg2 ;
31255 PyObject * obj0 = 0 ;
31256 PyObject * obj1 = 0 ;
31257 char *kwnames[] = {
31258 (char *) "self",(char *) "accept", NULL
31259 };
31260
31261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31263 if (SWIG_arg_fail(1)) SWIG_fail;
31264 {
31265 arg2 = (bool)(SWIG_As_bool(obj1));
31266 if (SWIG_arg_fail(2)) SWIG_fail;
31267 }
31268 {
31269 PyThreadState* __tstate = wxPyBeginAllowThreads();
31270 (arg1)->DragAcceptFiles(arg2);
31271
31272 wxPyEndAllowThreads(__tstate);
31273 if (PyErr_Occurred()) SWIG_fail;
31274 }
31275 Py_INCREF(Py_None); resultobj = Py_None;
31276 return resultobj;
31277 fail:
31278 return NULL;
31279 }
31280
31281
31282 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31283 PyObject *resultobj;
31284 wxWindow *arg1 = (wxWindow *) 0 ;
31285 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31286 PyObject * obj0 = 0 ;
31287 PyObject * obj1 = 0 ;
31288 char *kwnames[] = {
31289 (char *) "self",(char *) "constraints", NULL
31290 };
31291
31292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31294 if (SWIG_arg_fail(1)) SWIG_fail;
31295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31296 if (SWIG_arg_fail(2)) SWIG_fail;
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 (arg1)->SetConstraints(arg2);
31300
31301 wxPyEndAllowThreads(__tstate);
31302 if (PyErr_Occurred()) SWIG_fail;
31303 }
31304 Py_INCREF(Py_None); resultobj = Py_None;
31305 return resultobj;
31306 fail:
31307 return NULL;
31308 }
31309
31310
31311 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31312 PyObject *resultobj;
31313 wxWindow *arg1 = (wxWindow *) 0 ;
31314 wxLayoutConstraints *result;
31315 PyObject * obj0 = 0 ;
31316 char *kwnames[] = {
31317 (char *) "self", NULL
31318 };
31319
31320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31322 if (SWIG_arg_fail(1)) SWIG_fail;
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31326
31327 wxPyEndAllowThreads(__tstate);
31328 if (PyErr_Occurred()) SWIG_fail;
31329 }
31330 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31331 return resultobj;
31332 fail:
31333 return NULL;
31334 }
31335
31336
31337 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31338 PyObject *resultobj;
31339 wxWindow *arg1 = (wxWindow *) 0 ;
31340 bool arg2 ;
31341 PyObject * obj0 = 0 ;
31342 PyObject * obj1 = 0 ;
31343 char *kwnames[] = {
31344 (char *) "self",(char *) "autoLayout", NULL
31345 };
31346
31347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31349 if (SWIG_arg_fail(1)) SWIG_fail;
31350 {
31351 arg2 = (bool)(SWIG_As_bool(obj1));
31352 if (SWIG_arg_fail(2)) SWIG_fail;
31353 }
31354 {
31355 PyThreadState* __tstate = wxPyBeginAllowThreads();
31356 (arg1)->SetAutoLayout(arg2);
31357
31358 wxPyEndAllowThreads(__tstate);
31359 if (PyErr_Occurred()) SWIG_fail;
31360 }
31361 Py_INCREF(Py_None); resultobj = Py_None;
31362 return resultobj;
31363 fail:
31364 return NULL;
31365 }
31366
31367
31368 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31369 PyObject *resultobj;
31370 wxWindow *arg1 = (wxWindow *) 0 ;
31371 bool result;
31372 PyObject * obj0 = 0 ;
31373 char *kwnames[] = {
31374 (char *) "self", NULL
31375 };
31376
31377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31379 if (SWIG_arg_fail(1)) SWIG_fail;
31380 {
31381 PyThreadState* __tstate = wxPyBeginAllowThreads();
31382 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31383
31384 wxPyEndAllowThreads(__tstate);
31385 if (PyErr_Occurred()) SWIG_fail;
31386 }
31387 {
31388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31389 }
31390 return resultobj;
31391 fail:
31392 return NULL;
31393 }
31394
31395
31396 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31397 PyObject *resultobj;
31398 wxWindow *arg1 = (wxWindow *) 0 ;
31399 bool result;
31400 PyObject * obj0 = 0 ;
31401 char *kwnames[] = {
31402 (char *) "self", NULL
31403 };
31404
31405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31407 if (SWIG_arg_fail(1)) SWIG_fail;
31408 {
31409 PyThreadState* __tstate = wxPyBeginAllowThreads();
31410 result = (bool)(arg1)->Layout();
31411
31412 wxPyEndAllowThreads(__tstate);
31413 if (PyErr_Occurred()) SWIG_fail;
31414 }
31415 {
31416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31417 }
31418 return resultobj;
31419 fail:
31420 return NULL;
31421 }
31422
31423
31424 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31425 PyObject *resultobj;
31426 wxWindow *arg1 = (wxWindow *) 0 ;
31427 wxSizer *arg2 = (wxSizer *) 0 ;
31428 bool arg3 = (bool) true ;
31429 PyObject * obj0 = 0 ;
31430 PyObject * obj1 = 0 ;
31431 PyObject * obj2 = 0 ;
31432 char *kwnames[] = {
31433 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31434 };
31435
31436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31438 if (SWIG_arg_fail(1)) SWIG_fail;
31439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31440 if (SWIG_arg_fail(2)) SWIG_fail;
31441 if (obj2) {
31442 {
31443 arg3 = (bool)(SWIG_As_bool(obj2));
31444 if (SWIG_arg_fail(3)) SWIG_fail;
31445 }
31446 }
31447 {
31448 PyThreadState* __tstate = wxPyBeginAllowThreads();
31449 (arg1)->SetSizer(arg2,arg3);
31450
31451 wxPyEndAllowThreads(__tstate);
31452 if (PyErr_Occurred()) SWIG_fail;
31453 }
31454 Py_INCREF(Py_None); resultobj = Py_None;
31455 return resultobj;
31456 fail:
31457 return NULL;
31458 }
31459
31460
31461 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31462 PyObject *resultobj;
31463 wxWindow *arg1 = (wxWindow *) 0 ;
31464 wxSizer *arg2 = (wxSizer *) 0 ;
31465 bool arg3 = (bool) true ;
31466 PyObject * obj0 = 0 ;
31467 PyObject * obj1 = 0 ;
31468 PyObject * obj2 = 0 ;
31469 char *kwnames[] = {
31470 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31471 };
31472
31473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31475 if (SWIG_arg_fail(1)) SWIG_fail;
31476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31477 if (SWIG_arg_fail(2)) SWIG_fail;
31478 if (obj2) {
31479 {
31480 arg3 = (bool)(SWIG_As_bool(obj2));
31481 if (SWIG_arg_fail(3)) SWIG_fail;
31482 }
31483 }
31484 {
31485 PyThreadState* __tstate = wxPyBeginAllowThreads();
31486 (arg1)->SetSizerAndFit(arg2,arg3);
31487
31488 wxPyEndAllowThreads(__tstate);
31489 if (PyErr_Occurred()) SWIG_fail;
31490 }
31491 Py_INCREF(Py_None); resultobj = Py_None;
31492 return resultobj;
31493 fail:
31494 return NULL;
31495 }
31496
31497
31498 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31499 PyObject *resultobj;
31500 wxWindow *arg1 = (wxWindow *) 0 ;
31501 wxSizer *result;
31502 PyObject * obj0 = 0 ;
31503 char *kwnames[] = {
31504 (char *) "self", NULL
31505 };
31506
31507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31509 if (SWIG_arg_fail(1)) SWIG_fail;
31510 {
31511 PyThreadState* __tstate = wxPyBeginAllowThreads();
31512 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31513
31514 wxPyEndAllowThreads(__tstate);
31515 if (PyErr_Occurred()) SWIG_fail;
31516 }
31517 {
31518 resultobj = wxPyMake_wxSizer(result, 0);
31519 }
31520 return resultobj;
31521 fail:
31522 return NULL;
31523 }
31524
31525
31526 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31527 PyObject *resultobj;
31528 wxWindow *arg1 = (wxWindow *) 0 ;
31529 wxSizer *arg2 = (wxSizer *) 0 ;
31530 PyObject * obj0 = 0 ;
31531 PyObject * obj1 = 0 ;
31532 char *kwnames[] = {
31533 (char *) "self",(char *) "sizer", NULL
31534 };
31535
31536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31538 if (SWIG_arg_fail(1)) SWIG_fail;
31539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31540 if (SWIG_arg_fail(2)) SWIG_fail;
31541 {
31542 PyThreadState* __tstate = wxPyBeginAllowThreads();
31543 (arg1)->SetContainingSizer(arg2);
31544
31545 wxPyEndAllowThreads(__tstate);
31546 if (PyErr_Occurred()) SWIG_fail;
31547 }
31548 Py_INCREF(Py_None); resultobj = Py_None;
31549 return resultobj;
31550 fail:
31551 return NULL;
31552 }
31553
31554
31555 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31556 PyObject *resultobj;
31557 wxWindow *arg1 = (wxWindow *) 0 ;
31558 wxSizer *result;
31559 PyObject * obj0 = 0 ;
31560 char *kwnames[] = {
31561 (char *) "self", NULL
31562 };
31563
31564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31566 if (SWIG_arg_fail(1)) SWIG_fail;
31567 {
31568 PyThreadState* __tstate = wxPyBeginAllowThreads();
31569 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31570
31571 wxPyEndAllowThreads(__tstate);
31572 if (PyErr_Occurred()) SWIG_fail;
31573 }
31574 {
31575 resultobj = wxPyMake_wxSizer(result, 0);
31576 }
31577 return resultobj;
31578 fail:
31579 return NULL;
31580 }
31581
31582
31583 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31584 PyObject *resultobj;
31585 wxWindow *arg1 = (wxWindow *) 0 ;
31586 PyObject * obj0 = 0 ;
31587 char *kwnames[] = {
31588 (char *) "self", NULL
31589 };
31590
31591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31593 if (SWIG_arg_fail(1)) SWIG_fail;
31594 {
31595 PyThreadState* __tstate = wxPyBeginAllowThreads();
31596 (arg1)->InheritAttributes();
31597
31598 wxPyEndAllowThreads(__tstate);
31599 if (PyErr_Occurred()) SWIG_fail;
31600 }
31601 Py_INCREF(Py_None); resultobj = Py_None;
31602 return resultobj;
31603 fail:
31604 return NULL;
31605 }
31606
31607
31608 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31609 PyObject *resultobj;
31610 wxWindow *arg1 = (wxWindow *) 0 ;
31611 bool result;
31612 PyObject * obj0 = 0 ;
31613 char *kwnames[] = {
31614 (char *) "self", NULL
31615 };
31616
31617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31619 if (SWIG_arg_fail(1)) SWIG_fail;
31620 {
31621 PyThreadState* __tstate = wxPyBeginAllowThreads();
31622 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31623
31624 wxPyEndAllowThreads(__tstate);
31625 if (PyErr_Occurred()) SWIG_fail;
31626 }
31627 {
31628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31629 }
31630 return resultobj;
31631 fail:
31632 return NULL;
31633 }
31634
31635
31636 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31637 PyObject *obj;
31638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31639 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31640 Py_INCREF(obj);
31641 return Py_BuildValue((char *)"");
31642 }
31643 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31644 PyObject *resultobj;
31645 long arg1 ;
31646 wxWindow *arg2 = (wxWindow *) NULL ;
31647 wxWindow *result;
31648 PyObject * obj0 = 0 ;
31649 PyObject * obj1 = 0 ;
31650 char *kwnames[] = {
31651 (char *) "id",(char *) "parent", NULL
31652 };
31653
31654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31655 {
31656 arg1 = (long)(SWIG_As_long(obj0));
31657 if (SWIG_arg_fail(1)) SWIG_fail;
31658 }
31659 if (obj1) {
31660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31661 if (SWIG_arg_fail(2)) SWIG_fail;
31662 }
31663 {
31664 if (!wxPyCheckForApp()) SWIG_fail;
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31667
31668 wxPyEndAllowThreads(__tstate);
31669 if (PyErr_Occurred()) SWIG_fail;
31670 }
31671 {
31672 resultobj = wxPyMake_wxObject(result, 0);
31673 }
31674 return resultobj;
31675 fail:
31676 return NULL;
31677 }
31678
31679
31680 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31681 PyObject *resultobj;
31682 wxString *arg1 = 0 ;
31683 wxWindow *arg2 = (wxWindow *) NULL ;
31684 wxWindow *result;
31685 bool temp1 = false ;
31686 PyObject * obj0 = 0 ;
31687 PyObject * obj1 = 0 ;
31688 char *kwnames[] = {
31689 (char *) "name",(char *) "parent", NULL
31690 };
31691
31692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31693 {
31694 arg1 = wxString_in_helper(obj0);
31695 if (arg1 == NULL) SWIG_fail;
31696 temp1 = true;
31697 }
31698 if (obj1) {
31699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31700 if (SWIG_arg_fail(2)) SWIG_fail;
31701 }
31702 {
31703 if (!wxPyCheckForApp()) SWIG_fail;
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31706
31707 wxPyEndAllowThreads(__tstate);
31708 if (PyErr_Occurred()) SWIG_fail;
31709 }
31710 {
31711 resultobj = wxPyMake_wxObject(result, 0);
31712 }
31713 {
31714 if (temp1)
31715 delete arg1;
31716 }
31717 return resultobj;
31718 fail:
31719 {
31720 if (temp1)
31721 delete arg1;
31722 }
31723 return NULL;
31724 }
31725
31726
31727 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31728 PyObject *resultobj;
31729 wxString *arg1 = 0 ;
31730 wxWindow *arg2 = (wxWindow *) NULL ;
31731 wxWindow *result;
31732 bool temp1 = false ;
31733 PyObject * obj0 = 0 ;
31734 PyObject * obj1 = 0 ;
31735 char *kwnames[] = {
31736 (char *) "label",(char *) "parent", NULL
31737 };
31738
31739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31740 {
31741 arg1 = wxString_in_helper(obj0);
31742 if (arg1 == NULL) SWIG_fail;
31743 temp1 = true;
31744 }
31745 if (obj1) {
31746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31747 if (SWIG_arg_fail(2)) SWIG_fail;
31748 }
31749 {
31750 if (!wxPyCheckForApp()) SWIG_fail;
31751 PyThreadState* __tstate = wxPyBeginAllowThreads();
31752 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31753
31754 wxPyEndAllowThreads(__tstate);
31755 if (PyErr_Occurred()) SWIG_fail;
31756 }
31757 {
31758 resultobj = wxPyMake_wxObject(result, 0);
31759 }
31760 {
31761 if (temp1)
31762 delete arg1;
31763 }
31764 return resultobj;
31765 fail:
31766 {
31767 if (temp1)
31768 delete arg1;
31769 }
31770 return NULL;
31771 }
31772
31773
31774 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31775 PyObject *resultobj;
31776 wxWindow *arg1 = (wxWindow *) 0 ;
31777 unsigned long arg2 ;
31778 wxWindow *result;
31779 PyObject * obj0 = 0 ;
31780 PyObject * obj1 = 0 ;
31781 char *kwnames[] = {
31782 (char *) "parent",(char *) "_hWnd", NULL
31783 };
31784
31785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31787 if (SWIG_arg_fail(1)) SWIG_fail;
31788 {
31789 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31790 if (SWIG_arg_fail(2)) SWIG_fail;
31791 }
31792 {
31793 PyThreadState* __tstate = wxPyBeginAllowThreads();
31794 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31795
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 {
31800 resultobj = wxPyMake_wxObject(result, 0);
31801 }
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31809 PyObject *resultobj;
31810 wxValidator *result;
31811 char *kwnames[] = {
31812 NULL
31813 };
31814
31815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31816 {
31817 PyThreadState* __tstate = wxPyBeginAllowThreads();
31818 result = (wxValidator *)new wxValidator();
31819
31820 wxPyEndAllowThreads(__tstate);
31821 if (PyErr_Occurred()) SWIG_fail;
31822 }
31823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31824 return resultobj;
31825 fail:
31826 return NULL;
31827 }
31828
31829
31830 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31831 PyObject *resultobj;
31832 wxValidator *arg1 = (wxValidator *) 0 ;
31833 wxValidator *result;
31834 PyObject * obj0 = 0 ;
31835 char *kwnames[] = {
31836 (char *) "self", NULL
31837 };
31838
31839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31841 if (SWIG_arg_fail(1)) SWIG_fail;
31842 {
31843 PyThreadState* __tstate = wxPyBeginAllowThreads();
31844 result = (wxValidator *)(arg1)->Clone();
31845
31846 wxPyEndAllowThreads(__tstate);
31847 if (PyErr_Occurred()) SWIG_fail;
31848 }
31849 {
31850 resultobj = wxPyMake_wxObject(result, 0);
31851 }
31852 return resultobj;
31853 fail:
31854 return NULL;
31855 }
31856
31857
31858 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31859 PyObject *resultobj;
31860 wxValidator *arg1 = (wxValidator *) 0 ;
31861 wxWindow *arg2 = (wxWindow *) 0 ;
31862 bool result;
31863 PyObject * obj0 = 0 ;
31864 PyObject * obj1 = 0 ;
31865 char *kwnames[] = {
31866 (char *) "self",(char *) "parent", NULL
31867 };
31868
31869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31871 if (SWIG_arg_fail(1)) SWIG_fail;
31872 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31873 if (SWIG_arg_fail(2)) SWIG_fail;
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 result = (bool)(arg1)->Validate(arg2);
31877
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 {
31882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31883 }
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31891 PyObject *resultobj;
31892 wxValidator *arg1 = (wxValidator *) 0 ;
31893 bool result;
31894 PyObject * obj0 = 0 ;
31895 char *kwnames[] = {
31896 (char *) "self", NULL
31897 };
31898
31899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31901 if (SWIG_arg_fail(1)) SWIG_fail;
31902 {
31903 PyThreadState* __tstate = wxPyBeginAllowThreads();
31904 result = (bool)(arg1)->TransferToWindow();
31905
31906 wxPyEndAllowThreads(__tstate);
31907 if (PyErr_Occurred()) SWIG_fail;
31908 }
31909 {
31910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31911 }
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31919 PyObject *resultobj;
31920 wxValidator *arg1 = (wxValidator *) 0 ;
31921 bool result;
31922 PyObject * obj0 = 0 ;
31923 char *kwnames[] = {
31924 (char *) "self", NULL
31925 };
31926
31927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31929 if (SWIG_arg_fail(1)) SWIG_fail;
31930 {
31931 PyThreadState* __tstate = wxPyBeginAllowThreads();
31932 result = (bool)(arg1)->TransferFromWindow();
31933
31934 wxPyEndAllowThreads(__tstate);
31935 if (PyErr_Occurred()) SWIG_fail;
31936 }
31937 {
31938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31939 }
31940 return resultobj;
31941 fail:
31942 return NULL;
31943 }
31944
31945
31946 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31947 PyObject *resultobj;
31948 wxValidator *arg1 = (wxValidator *) 0 ;
31949 wxWindow *result;
31950 PyObject * obj0 = 0 ;
31951 char *kwnames[] = {
31952 (char *) "self", NULL
31953 };
31954
31955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31957 if (SWIG_arg_fail(1)) SWIG_fail;
31958 {
31959 PyThreadState* __tstate = wxPyBeginAllowThreads();
31960 result = (wxWindow *)(arg1)->GetWindow();
31961
31962 wxPyEndAllowThreads(__tstate);
31963 if (PyErr_Occurred()) SWIG_fail;
31964 }
31965 {
31966 resultobj = wxPyMake_wxObject(result, 0);
31967 }
31968 return resultobj;
31969 fail:
31970 return NULL;
31971 }
31972
31973
31974 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31975 PyObject *resultobj;
31976 wxValidator *arg1 = (wxValidator *) 0 ;
31977 wxWindow *arg2 = (wxWindow *) 0 ;
31978 PyObject * obj0 = 0 ;
31979 PyObject * obj1 = 0 ;
31980 char *kwnames[] = {
31981 (char *) "self",(char *) "window", NULL
31982 };
31983
31984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31986 if (SWIG_arg_fail(1)) SWIG_fail;
31987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31988 if (SWIG_arg_fail(2)) SWIG_fail;
31989 {
31990 PyThreadState* __tstate = wxPyBeginAllowThreads();
31991 (arg1)->SetWindow(arg2);
31992
31993 wxPyEndAllowThreads(__tstate);
31994 if (PyErr_Occurred()) SWIG_fail;
31995 }
31996 Py_INCREF(Py_None); resultobj = Py_None;
31997 return resultobj;
31998 fail:
31999 return NULL;
32000 }
32001
32002
32003 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32004 PyObject *resultobj;
32005 bool result;
32006 char *kwnames[] = {
32007 NULL
32008 };
32009
32010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32011 {
32012 PyThreadState* __tstate = wxPyBeginAllowThreads();
32013 result = (bool)wxValidator::IsSilent();
32014
32015 wxPyEndAllowThreads(__tstate);
32016 if (PyErr_Occurred()) SWIG_fail;
32017 }
32018 {
32019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32020 }
32021 return resultobj;
32022 fail:
32023 return NULL;
32024 }
32025
32026
32027 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32028 PyObject *resultobj;
32029 int arg1 = (int) true ;
32030 PyObject * obj0 = 0 ;
32031 char *kwnames[] = {
32032 (char *) "doIt", NULL
32033 };
32034
32035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32036 if (obj0) {
32037 {
32038 arg1 = (int)(SWIG_As_int(obj0));
32039 if (SWIG_arg_fail(1)) SWIG_fail;
32040 }
32041 }
32042 {
32043 PyThreadState* __tstate = wxPyBeginAllowThreads();
32044 wxValidator::SetBellOnError(arg1);
32045
32046 wxPyEndAllowThreads(__tstate);
32047 if (PyErr_Occurred()) SWIG_fail;
32048 }
32049 Py_INCREF(Py_None); resultobj = Py_None;
32050 return resultobj;
32051 fail:
32052 return NULL;
32053 }
32054
32055
32056 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32057 PyObject *obj;
32058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32059 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32060 Py_INCREF(obj);
32061 return Py_BuildValue((char *)"");
32062 }
32063 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32064 PyObject *resultobj;
32065 wxPyValidator *result;
32066 char *kwnames[] = {
32067 NULL
32068 };
32069
32070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32071 {
32072 PyThreadState* __tstate = wxPyBeginAllowThreads();
32073 result = (wxPyValidator *)new wxPyValidator();
32074
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32079 return resultobj;
32080 fail:
32081 return NULL;
32082 }
32083
32084
32085 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32086 PyObject *resultobj;
32087 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32088 PyObject *arg2 = (PyObject *) 0 ;
32089 PyObject *arg3 = (PyObject *) 0 ;
32090 int arg4 = (int) true ;
32091 PyObject * obj0 = 0 ;
32092 PyObject * obj1 = 0 ;
32093 PyObject * obj2 = 0 ;
32094 PyObject * obj3 = 0 ;
32095 char *kwnames[] = {
32096 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32097 };
32098
32099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32101 if (SWIG_arg_fail(1)) SWIG_fail;
32102 arg2 = obj1;
32103 arg3 = obj2;
32104 if (obj3) {
32105 {
32106 arg4 = (int)(SWIG_As_int(obj3));
32107 if (SWIG_arg_fail(4)) SWIG_fail;
32108 }
32109 }
32110 {
32111 PyThreadState* __tstate = wxPyBeginAllowThreads();
32112 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32113
32114 wxPyEndAllowThreads(__tstate);
32115 if (PyErr_Occurred()) SWIG_fail;
32116 }
32117 Py_INCREF(Py_None); resultobj = Py_None;
32118 return resultobj;
32119 fail:
32120 return NULL;
32121 }
32122
32123
32124 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32125 PyObject *obj;
32126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32127 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32128 Py_INCREF(obj);
32129 return Py_BuildValue((char *)"");
32130 }
32131 static int _wrap_DefaultValidator_set(PyObject *) {
32132 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32133 return 1;
32134 }
32135
32136
32137 static PyObject *_wrap_DefaultValidator_get(void) {
32138 PyObject *pyobj;
32139
32140 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32141 return pyobj;
32142 }
32143
32144
32145 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32146 PyObject *resultobj;
32147 wxString const &arg1_defvalue = wxPyEmptyString ;
32148 wxString *arg1 = (wxString *) &arg1_defvalue ;
32149 long arg2 = (long) 0 ;
32150 wxMenu *result;
32151 bool temp1 = false ;
32152 PyObject * obj0 = 0 ;
32153 PyObject * obj1 = 0 ;
32154 char *kwnames[] = {
32155 (char *) "title",(char *) "style", NULL
32156 };
32157
32158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32159 if (obj0) {
32160 {
32161 arg1 = wxString_in_helper(obj0);
32162 if (arg1 == NULL) SWIG_fail;
32163 temp1 = true;
32164 }
32165 }
32166 if (obj1) {
32167 {
32168 arg2 = (long)(SWIG_As_long(obj1));
32169 if (SWIG_arg_fail(2)) SWIG_fail;
32170 }
32171 }
32172 {
32173 if (!wxPyCheckForApp()) SWIG_fail;
32174 PyThreadState* __tstate = wxPyBeginAllowThreads();
32175 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32176
32177 wxPyEndAllowThreads(__tstate);
32178 if (PyErr_Occurred()) SWIG_fail;
32179 }
32180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32181 {
32182 if (temp1)
32183 delete arg1;
32184 }
32185 return resultobj;
32186 fail:
32187 {
32188 if (temp1)
32189 delete arg1;
32190 }
32191 return NULL;
32192 }
32193
32194
32195 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32196 PyObject *resultobj;
32197 wxMenu *arg1 = (wxMenu *) 0 ;
32198 int arg2 ;
32199 wxString *arg3 = 0 ;
32200 wxString const &arg4_defvalue = wxPyEmptyString ;
32201 wxString *arg4 = (wxString *) &arg4_defvalue ;
32202 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32203 wxMenuItem *result;
32204 bool temp3 = false ;
32205 bool temp4 = false ;
32206 PyObject * obj0 = 0 ;
32207 PyObject * obj1 = 0 ;
32208 PyObject * obj2 = 0 ;
32209 PyObject * obj3 = 0 ;
32210 PyObject * obj4 = 0 ;
32211 char *kwnames[] = {
32212 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32213 };
32214
32215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32217 if (SWIG_arg_fail(1)) SWIG_fail;
32218 {
32219 arg2 = (int)(SWIG_As_int(obj1));
32220 if (SWIG_arg_fail(2)) SWIG_fail;
32221 }
32222 {
32223 arg3 = wxString_in_helper(obj2);
32224 if (arg3 == NULL) SWIG_fail;
32225 temp3 = true;
32226 }
32227 if (obj3) {
32228 {
32229 arg4 = wxString_in_helper(obj3);
32230 if (arg4 == NULL) SWIG_fail;
32231 temp4 = true;
32232 }
32233 }
32234 if (obj4) {
32235 {
32236 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32237 if (SWIG_arg_fail(5)) SWIG_fail;
32238 }
32239 }
32240 {
32241 PyThreadState* __tstate = wxPyBeginAllowThreads();
32242 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32243
32244 wxPyEndAllowThreads(__tstate);
32245 if (PyErr_Occurred()) SWIG_fail;
32246 }
32247 {
32248 resultobj = wxPyMake_wxObject(result, 0);
32249 }
32250 {
32251 if (temp3)
32252 delete arg3;
32253 }
32254 {
32255 if (temp4)
32256 delete arg4;
32257 }
32258 return resultobj;
32259 fail:
32260 {
32261 if (temp3)
32262 delete arg3;
32263 }
32264 {
32265 if (temp4)
32266 delete arg4;
32267 }
32268 return NULL;
32269 }
32270
32271
32272 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32273 PyObject *resultobj;
32274 wxMenu *arg1 = (wxMenu *) 0 ;
32275 wxMenuItem *result;
32276 PyObject * obj0 = 0 ;
32277 char *kwnames[] = {
32278 (char *) "self", NULL
32279 };
32280
32281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32283 if (SWIG_arg_fail(1)) SWIG_fail;
32284 {
32285 PyThreadState* __tstate = wxPyBeginAllowThreads();
32286 result = (wxMenuItem *)(arg1)->AppendSeparator();
32287
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 {
32292 resultobj = wxPyMake_wxObject(result, 0);
32293 }
32294 return resultobj;
32295 fail:
32296 return NULL;
32297 }
32298
32299
32300 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32301 PyObject *resultobj;
32302 wxMenu *arg1 = (wxMenu *) 0 ;
32303 int arg2 ;
32304 wxString *arg3 = 0 ;
32305 wxString const &arg4_defvalue = wxPyEmptyString ;
32306 wxString *arg4 = (wxString *) &arg4_defvalue ;
32307 wxMenuItem *result;
32308 bool temp3 = false ;
32309 bool temp4 = false ;
32310 PyObject * obj0 = 0 ;
32311 PyObject * obj1 = 0 ;
32312 PyObject * obj2 = 0 ;
32313 PyObject * obj3 = 0 ;
32314 char *kwnames[] = {
32315 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32316 };
32317
32318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32320 if (SWIG_arg_fail(1)) SWIG_fail;
32321 {
32322 arg2 = (int)(SWIG_As_int(obj1));
32323 if (SWIG_arg_fail(2)) SWIG_fail;
32324 }
32325 {
32326 arg3 = wxString_in_helper(obj2);
32327 if (arg3 == NULL) SWIG_fail;
32328 temp3 = true;
32329 }
32330 if (obj3) {
32331 {
32332 arg4 = wxString_in_helper(obj3);
32333 if (arg4 == NULL) SWIG_fail;
32334 temp4 = true;
32335 }
32336 }
32337 {
32338 PyThreadState* __tstate = wxPyBeginAllowThreads();
32339 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32340
32341 wxPyEndAllowThreads(__tstate);
32342 if (PyErr_Occurred()) SWIG_fail;
32343 }
32344 {
32345 resultobj = wxPyMake_wxObject(result, 0);
32346 }
32347 {
32348 if (temp3)
32349 delete arg3;
32350 }
32351 {
32352 if (temp4)
32353 delete arg4;
32354 }
32355 return resultobj;
32356 fail:
32357 {
32358 if (temp3)
32359 delete arg3;
32360 }
32361 {
32362 if (temp4)
32363 delete arg4;
32364 }
32365 return NULL;
32366 }
32367
32368
32369 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32370 PyObject *resultobj;
32371 wxMenu *arg1 = (wxMenu *) 0 ;
32372 int arg2 ;
32373 wxString *arg3 = 0 ;
32374 wxString const &arg4_defvalue = wxPyEmptyString ;
32375 wxString *arg4 = (wxString *) &arg4_defvalue ;
32376 wxMenuItem *result;
32377 bool temp3 = false ;
32378 bool temp4 = false ;
32379 PyObject * obj0 = 0 ;
32380 PyObject * obj1 = 0 ;
32381 PyObject * obj2 = 0 ;
32382 PyObject * obj3 = 0 ;
32383 char *kwnames[] = {
32384 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32385 };
32386
32387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32389 if (SWIG_arg_fail(1)) SWIG_fail;
32390 {
32391 arg2 = (int)(SWIG_As_int(obj1));
32392 if (SWIG_arg_fail(2)) SWIG_fail;
32393 }
32394 {
32395 arg3 = wxString_in_helper(obj2);
32396 if (arg3 == NULL) SWIG_fail;
32397 temp3 = true;
32398 }
32399 if (obj3) {
32400 {
32401 arg4 = wxString_in_helper(obj3);
32402 if (arg4 == NULL) SWIG_fail;
32403 temp4 = true;
32404 }
32405 }
32406 {
32407 PyThreadState* __tstate = wxPyBeginAllowThreads();
32408 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32409
32410 wxPyEndAllowThreads(__tstate);
32411 if (PyErr_Occurred()) SWIG_fail;
32412 }
32413 {
32414 resultobj = wxPyMake_wxObject(result, 0);
32415 }
32416 {
32417 if (temp3)
32418 delete arg3;
32419 }
32420 {
32421 if (temp4)
32422 delete arg4;
32423 }
32424 return resultobj;
32425 fail:
32426 {
32427 if (temp3)
32428 delete arg3;
32429 }
32430 {
32431 if (temp4)
32432 delete arg4;
32433 }
32434 return NULL;
32435 }
32436
32437
32438 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32439 PyObject *resultobj;
32440 wxMenu *arg1 = (wxMenu *) 0 ;
32441 int arg2 ;
32442 wxString *arg3 = 0 ;
32443 wxMenu *arg4 = (wxMenu *) 0 ;
32444 wxString const &arg5_defvalue = wxPyEmptyString ;
32445 wxString *arg5 = (wxString *) &arg5_defvalue ;
32446 wxMenuItem *result;
32447 bool temp3 = false ;
32448 bool temp5 = false ;
32449 PyObject * obj0 = 0 ;
32450 PyObject * obj1 = 0 ;
32451 PyObject * obj2 = 0 ;
32452 PyObject * obj3 = 0 ;
32453 PyObject * obj4 = 0 ;
32454 char *kwnames[] = {
32455 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32456 };
32457
32458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32460 if (SWIG_arg_fail(1)) SWIG_fail;
32461 {
32462 arg2 = (int)(SWIG_As_int(obj1));
32463 if (SWIG_arg_fail(2)) SWIG_fail;
32464 }
32465 {
32466 arg3 = wxString_in_helper(obj2);
32467 if (arg3 == NULL) SWIG_fail;
32468 temp3 = true;
32469 }
32470 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32471 if (SWIG_arg_fail(4)) SWIG_fail;
32472 if (obj4) {
32473 {
32474 arg5 = wxString_in_helper(obj4);
32475 if (arg5 == NULL) SWIG_fail;
32476 temp5 = true;
32477 }
32478 }
32479 {
32480 PyThreadState* __tstate = wxPyBeginAllowThreads();
32481 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32482
32483 wxPyEndAllowThreads(__tstate);
32484 if (PyErr_Occurred()) SWIG_fail;
32485 }
32486 {
32487 resultobj = wxPyMake_wxObject(result, 0);
32488 }
32489 {
32490 if (temp3)
32491 delete arg3;
32492 }
32493 {
32494 if (temp5)
32495 delete arg5;
32496 }
32497 return resultobj;
32498 fail:
32499 {
32500 if (temp3)
32501 delete arg3;
32502 }
32503 {
32504 if (temp5)
32505 delete arg5;
32506 }
32507 return NULL;
32508 }
32509
32510
32511 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32512 PyObject *resultobj;
32513 wxMenu *arg1 = (wxMenu *) 0 ;
32514 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32515 wxMenuItem *result;
32516 PyObject * obj0 = 0 ;
32517 PyObject * obj1 = 0 ;
32518 char *kwnames[] = {
32519 (char *) "self",(char *) "item", NULL
32520 };
32521
32522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32524 if (SWIG_arg_fail(1)) SWIG_fail;
32525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32526 if (SWIG_arg_fail(2)) SWIG_fail;
32527 {
32528 PyThreadState* __tstate = wxPyBeginAllowThreads();
32529 result = (wxMenuItem *)(arg1)->Append(arg2);
32530
32531 wxPyEndAllowThreads(__tstate);
32532 if (PyErr_Occurred()) SWIG_fail;
32533 }
32534 {
32535 resultobj = wxPyMake_wxObject(result, 0);
32536 }
32537 return resultobj;
32538 fail:
32539 return NULL;
32540 }
32541
32542
32543 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32544 PyObject *resultobj;
32545 wxMenu *arg1 = (wxMenu *) 0 ;
32546 PyObject * obj0 = 0 ;
32547 char *kwnames[] = {
32548 (char *) "self", NULL
32549 };
32550
32551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32553 if (SWIG_arg_fail(1)) SWIG_fail;
32554 {
32555 PyThreadState* __tstate = wxPyBeginAllowThreads();
32556 (arg1)->Break();
32557
32558 wxPyEndAllowThreads(__tstate);
32559 if (PyErr_Occurred()) SWIG_fail;
32560 }
32561 Py_INCREF(Py_None); resultobj = Py_None;
32562 return resultobj;
32563 fail:
32564 return NULL;
32565 }
32566
32567
32568 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32569 PyObject *resultobj;
32570 wxMenu *arg1 = (wxMenu *) 0 ;
32571 size_t arg2 ;
32572 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32573 wxMenuItem *result;
32574 PyObject * obj0 = 0 ;
32575 PyObject * obj1 = 0 ;
32576 PyObject * obj2 = 0 ;
32577 char *kwnames[] = {
32578 (char *) "self",(char *) "pos",(char *) "item", NULL
32579 };
32580
32581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32583 if (SWIG_arg_fail(1)) SWIG_fail;
32584 {
32585 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32586 if (SWIG_arg_fail(2)) SWIG_fail;
32587 }
32588 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32589 if (SWIG_arg_fail(3)) SWIG_fail;
32590 {
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32593
32594 wxPyEndAllowThreads(__tstate);
32595 if (PyErr_Occurred()) SWIG_fail;
32596 }
32597 {
32598 resultobj = wxPyMake_wxObject(result, 0);
32599 }
32600 return resultobj;
32601 fail:
32602 return NULL;
32603 }
32604
32605
32606 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32607 PyObject *resultobj;
32608 wxMenu *arg1 = (wxMenu *) 0 ;
32609 size_t arg2 ;
32610 int arg3 ;
32611 wxString *arg4 = 0 ;
32612 wxString const &arg5_defvalue = wxPyEmptyString ;
32613 wxString *arg5 = (wxString *) &arg5_defvalue ;
32614 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32615 wxMenuItem *result;
32616 bool temp4 = false ;
32617 bool temp5 = false ;
32618 PyObject * obj0 = 0 ;
32619 PyObject * obj1 = 0 ;
32620 PyObject * obj2 = 0 ;
32621 PyObject * obj3 = 0 ;
32622 PyObject * obj4 = 0 ;
32623 PyObject * obj5 = 0 ;
32624 char *kwnames[] = {
32625 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32626 };
32627
32628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32630 if (SWIG_arg_fail(1)) SWIG_fail;
32631 {
32632 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32633 if (SWIG_arg_fail(2)) SWIG_fail;
32634 }
32635 {
32636 arg3 = (int)(SWIG_As_int(obj2));
32637 if (SWIG_arg_fail(3)) SWIG_fail;
32638 }
32639 {
32640 arg4 = wxString_in_helper(obj3);
32641 if (arg4 == NULL) SWIG_fail;
32642 temp4 = true;
32643 }
32644 if (obj4) {
32645 {
32646 arg5 = wxString_in_helper(obj4);
32647 if (arg5 == NULL) SWIG_fail;
32648 temp5 = true;
32649 }
32650 }
32651 if (obj5) {
32652 {
32653 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32654 if (SWIG_arg_fail(6)) SWIG_fail;
32655 }
32656 }
32657 {
32658 PyThreadState* __tstate = wxPyBeginAllowThreads();
32659 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32660
32661 wxPyEndAllowThreads(__tstate);
32662 if (PyErr_Occurred()) SWIG_fail;
32663 }
32664 {
32665 resultobj = wxPyMake_wxObject(result, 0);
32666 }
32667 {
32668 if (temp4)
32669 delete arg4;
32670 }
32671 {
32672 if (temp5)
32673 delete arg5;
32674 }
32675 return resultobj;
32676 fail:
32677 {
32678 if (temp4)
32679 delete arg4;
32680 }
32681 {
32682 if (temp5)
32683 delete arg5;
32684 }
32685 return NULL;
32686 }
32687
32688
32689 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32690 PyObject *resultobj;
32691 wxMenu *arg1 = (wxMenu *) 0 ;
32692 size_t arg2 ;
32693 wxMenuItem *result;
32694 PyObject * obj0 = 0 ;
32695 PyObject * obj1 = 0 ;
32696 char *kwnames[] = {
32697 (char *) "self",(char *) "pos", NULL
32698 };
32699
32700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32702 if (SWIG_arg_fail(1)) SWIG_fail;
32703 {
32704 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32705 if (SWIG_arg_fail(2)) SWIG_fail;
32706 }
32707 {
32708 PyThreadState* __tstate = wxPyBeginAllowThreads();
32709 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32710
32711 wxPyEndAllowThreads(__tstate);
32712 if (PyErr_Occurred()) SWIG_fail;
32713 }
32714 {
32715 resultobj = wxPyMake_wxObject(result, 0);
32716 }
32717 return resultobj;
32718 fail:
32719 return NULL;
32720 }
32721
32722
32723 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32724 PyObject *resultobj;
32725 wxMenu *arg1 = (wxMenu *) 0 ;
32726 size_t arg2 ;
32727 int arg3 ;
32728 wxString *arg4 = 0 ;
32729 wxString const &arg5_defvalue = wxPyEmptyString ;
32730 wxString *arg5 = (wxString *) &arg5_defvalue ;
32731 wxMenuItem *result;
32732 bool temp4 = false ;
32733 bool temp5 = false ;
32734 PyObject * obj0 = 0 ;
32735 PyObject * obj1 = 0 ;
32736 PyObject * obj2 = 0 ;
32737 PyObject * obj3 = 0 ;
32738 PyObject * obj4 = 0 ;
32739 char *kwnames[] = {
32740 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32741 };
32742
32743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32745 if (SWIG_arg_fail(1)) SWIG_fail;
32746 {
32747 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32748 if (SWIG_arg_fail(2)) SWIG_fail;
32749 }
32750 {
32751 arg3 = (int)(SWIG_As_int(obj2));
32752 if (SWIG_arg_fail(3)) SWIG_fail;
32753 }
32754 {
32755 arg4 = wxString_in_helper(obj3);
32756 if (arg4 == NULL) SWIG_fail;
32757 temp4 = true;
32758 }
32759 if (obj4) {
32760 {
32761 arg5 = wxString_in_helper(obj4);
32762 if (arg5 == NULL) SWIG_fail;
32763 temp5 = true;
32764 }
32765 }
32766 {
32767 PyThreadState* __tstate = wxPyBeginAllowThreads();
32768 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32769
32770 wxPyEndAllowThreads(__tstate);
32771 if (PyErr_Occurred()) SWIG_fail;
32772 }
32773 {
32774 resultobj = wxPyMake_wxObject(result, 0);
32775 }
32776 {
32777 if (temp4)
32778 delete arg4;
32779 }
32780 {
32781 if (temp5)
32782 delete arg5;
32783 }
32784 return resultobj;
32785 fail:
32786 {
32787 if (temp4)
32788 delete arg4;
32789 }
32790 {
32791 if (temp5)
32792 delete arg5;
32793 }
32794 return NULL;
32795 }
32796
32797
32798 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32799 PyObject *resultobj;
32800 wxMenu *arg1 = (wxMenu *) 0 ;
32801 size_t arg2 ;
32802 int arg3 ;
32803 wxString *arg4 = 0 ;
32804 wxString const &arg5_defvalue = wxPyEmptyString ;
32805 wxString *arg5 = (wxString *) &arg5_defvalue ;
32806 wxMenuItem *result;
32807 bool temp4 = false ;
32808 bool temp5 = false ;
32809 PyObject * obj0 = 0 ;
32810 PyObject * obj1 = 0 ;
32811 PyObject * obj2 = 0 ;
32812 PyObject * obj3 = 0 ;
32813 PyObject * obj4 = 0 ;
32814 char *kwnames[] = {
32815 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32816 };
32817
32818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32820 if (SWIG_arg_fail(1)) SWIG_fail;
32821 {
32822 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32823 if (SWIG_arg_fail(2)) SWIG_fail;
32824 }
32825 {
32826 arg3 = (int)(SWIG_As_int(obj2));
32827 if (SWIG_arg_fail(3)) SWIG_fail;
32828 }
32829 {
32830 arg4 = wxString_in_helper(obj3);
32831 if (arg4 == NULL) SWIG_fail;
32832 temp4 = true;
32833 }
32834 if (obj4) {
32835 {
32836 arg5 = wxString_in_helper(obj4);
32837 if (arg5 == NULL) SWIG_fail;
32838 temp5 = true;
32839 }
32840 }
32841 {
32842 PyThreadState* __tstate = wxPyBeginAllowThreads();
32843 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32844
32845 wxPyEndAllowThreads(__tstate);
32846 if (PyErr_Occurred()) SWIG_fail;
32847 }
32848 {
32849 resultobj = wxPyMake_wxObject(result, 0);
32850 }
32851 {
32852 if (temp4)
32853 delete arg4;
32854 }
32855 {
32856 if (temp5)
32857 delete arg5;
32858 }
32859 return resultobj;
32860 fail:
32861 {
32862 if (temp4)
32863 delete arg4;
32864 }
32865 {
32866 if (temp5)
32867 delete arg5;
32868 }
32869 return NULL;
32870 }
32871
32872
32873 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32874 PyObject *resultobj;
32875 wxMenu *arg1 = (wxMenu *) 0 ;
32876 size_t arg2 ;
32877 int arg3 ;
32878 wxString *arg4 = 0 ;
32879 wxMenu *arg5 = (wxMenu *) 0 ;
32880 wxString const &arg6_defvalue = wxPyEmptyString ;
32881 wxString *arg6 = (wxString *) &arg6_defvalue ;
32882 wxMenuItem *result;
32883 bool temp4 = false ;
32884 bool temp6 = false ;
32885 PyObject * obj0 = 0 ;
32886 PyObject * obj1 = 0 ;
32887 PyObject * obj2 = 0 ;
32888 PyObject * obj3 = 0 ;
32889 PyObject * obj4 = 0 ;
32890 PyObject * obj5 = 0 ;
32891 char *kwnames[] = {
32892 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32893 };
32894
32895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32897 if (SWIG_arg_fail(1)) SWIG_fail;
32898 {
32899 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32900 if (SWIG_arg_fail(2)) SWIG_fail;
32901 }
32902 {
32903 arg3 = (int)(SWIG_As_int(obj2));
32904 if (SWIG_arg_fail(3)) SWIG_fail;
32905 }
32906 {
32907 arg4 = wxString_in_helper(obj3);
32908 if (arg4 == NULL) SWIG_fail;
32909 temp4 = true;
32910 }
32911 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32912 if (SWIG_arg_fail(5)) SWIG_fail;
32913 if (obj5) {
32914 {
32915 arg6 = wxString_in_helper(obj5);
32916 if (arg6 == NULL) SWIG_fail;
32917 temp6 = true;
32918 }
32919 }
32920 {
32921 PyThreadState* __tstate = wxPyBeginAllowThreads();
32922 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32923
32924 wxPyEndAllowThreads(__tstate);
32925 if (PyErr_Occurred()) SWIG_fail;
32926 }
32927 {
32928 resultobj = wxPyMake_wxObject(result, 0);
32929 }
32930 {
32931 if (temp4)
32932 delete arg4;
32933 }
32934 {
32935 if (temp6)
32936 delete arg6;
32937 }
32938 return resultobj;
32939 fail:
32940 {
32941 if (temp4)
32942 delete arg4;
32943 }
32944 {
32945 if (temp6)
32946 delete arg6;
32947 }
32948 return NULL;
32949 }
32950
32951
32952 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32953 PyObject *resultobj;
32954 wxMenu *arg1 = (wxMenu *) 0 ;
32955 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32956 wxMenuItem *result;
32957 PyObject * obj0 = 0 ;
32958 PyObject * obj1 = 0 ;
32959 char *kwnames[] = {
32960 (char *) "self",(char *) "item", NULL
32961 };
32962
32963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32965 if (SWIG_arg_fail(1)) SWIG_fail;
32966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32967 if (SWIG_arg_fail(2)) SWIG_fail;
32968 {
32969 PyThreadState* __tstate = wxPyBeginAllowThreads();
32970 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32971
32972 wxPyEndAllowThreads(__tstate);
32973 if (PyErr_Occurred()) SWIG_fail;
32974 }
32975 {
32976 resultobj = wxPyMake_wxObject(result, 0);
32977 }
32978 return resultobj;
32979 fail:
32980 return NULL;
32981 }
32982
32983
32984 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32985 PyObject *resultobj;
32986 wxMenu *arg1 = (wxMenu *) 0 ;
32987 int arg2 ;
32988 wxString *arg3 = 0 ;
32989 wxString const &arg4_defvalue = wxPyEmptyString ;
32990 wxString *arg4 = (wxString *) &arg4_defvalue ;
32991 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32992 wxMenuItem *result;
32993 bool temp3 = false ;
32994 bool temp4 = false ;
32995 PyObject * obj0 = 0 ;
32996 PyObject * obj1 = 0 ;
32997 PyObject * obj2 = 0 ;
32998 PyObject * obj3 = 0 ;
32999 PyObject * obj4 = 0 ;
33000 char *kwnames[] = {
33001 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33002 };
33003
33004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33006 if (SWIG_arg_fail(1)) SWIG_fail;
33007 {
33008 arg2 = (int)(SWIG_As_int(obj1));
33009 if (SWIG_arg_fail(2)) SWIG_fail;
33010 }
33011 {
33012 arg3 = wxString_in_helper(obj2);
33013 if (arg3 == NULL) SWIG_fail;
33014 temp3 = true;
33015 }
33016 if (obj3) {
33017 {
33018 arg4 = wxString_in_helper(obj3);
33019 if (arg4 == NULL) SWIG_fail;
33020 temp4 = true;
33021 }
33022 }
33023 if (obj4) {
33024 {
33025 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33026 if (SWIG_arg_fail(5)) SWIG_fail;
33027 }
33028 }
33029 {
33030 PyThreadState* __tstate = wxPyBeginAllowThreads();
33031 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33032
33033 wxPyEndAllowThreads(__tstate);
33034 if (PyErr_Occurred()) SWIG_fail;
33035 }
33036 {
33037 resultobj = wxPyMake_wxObject(result, 0);
33038 }
33039 {
33040 if (temp3)
33041 delete arg3;
33042 }
33043 {
33044 if (temp4)
33045 delete arg4;
33046 }
33047 return resultobj;
33048 fail:
33049 {
33050 if (temp3)
33051 delete arg3;
33052 }
33053 {
33054 if (temp4)
33055 delete arg4;
33056 }
33057 return NULL;
33058 }
33059
33060
33061 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33062 PyObject *resultobj;
33063 wxMenu *arg1 = (wxMenu *) 0 ;
33064 wxMenuItem *result;
33065 PyObject * obj0 = 0 ;
33066 char *kwnames[] = {
33067 (char *) "self", NULL
33068 };
33069
33070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33072 if (SWIG_arg_fail(1)) SWIG_fail;
33073 {
33074 PyThreadState* __tstate = wxPyBeginAllowThreads();
33075 result = (wxMenuItem *)(arg1)->PrependSeparator();
33076
33077 wxPyEndAllowThreads(__tstate);
33078 if (PyErr_Occurred()) SWIG_fail;
33079 }
33080 {
33081 resultobj = wxPyMake_wxObject(result, 0);
33082 }
33083 return resultobj;
33084 fail:
33085 return NULL;
33086 }
33087
33088
33089 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33090 PyObject *resultobj;
33091 wxMenu *arg1 = (wxMenu *) 0 ;
33092 int arg2 ;
33093 wxString *arg3 = 0 ;
33094 wxString const &arg4_defvalue = wxPyEmptyString ;
33095 wxString *arg4 = (wxString *) &arg4_defvalue ;
33096 wxMenuItem *result;
33097 bool temp3 = false ;
33098 bool temp4 = false ;
33099 PyObject * obj0 = 0 ;
33100 PyObject * obj1 = 0 ;
33101 PyObject * obj2 = 0 ;
33102 PyObject * obj3 = 0 ;
33103 char *kwnames[] = {
33104 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33105 };
33106
33107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33109 if (SWIG_arg_fail(1)) SWIG_fail;
33110 {
33111 arg2 = (int)(SWIG_As_int(obj1));
33112 if (SWIG_arg_fail(2)) SWIG_fail;
33113 }
33114 {
33115 arg3 = wxString_in_helper(obj2);
33116 if (arg3 == NULL) SWIG_fail;
33117 temp3 = true;
33118 }
33119 if (obj3) {
33120 {
33121 arg4 = wxString_in_helper(obj3);
33122 if (arg4 == NULL) SWIG_fail;
33123 temp4 = true;
33124 }
33125 }
33126 {
33127 PyThreadState* __tstate = wxPyBeginAllowThreads();
33128 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33129
33130 wxPyEndAllowThreads(__tstate);
33131 if (PyErr_Occurred()) SWIG_fail;
33132 }
33133 {
33134 resultobj = wxPyMake_wxObject(result, 0);
33135 }
33136 {
33137 if (temp3)
33138 delete arg3;
33139 }
33140 {
33141 if (temp4)
33142 delete arg4;
33143 }
33144 return resultobj;
33145 fail:
33146 {
33147 if (temp3)
33148 delete arg3;
33149 }
33150 {
33151 if (temp4)
33152 delete arg4;
33153 }
33154 return NULL;
33155 }
33156
33157
33158 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33159 PyObject *resultobj;
33160 wxMenu *arg1 = (wxMenu *) 0 ;
33161 int arg2 ;
33162 wxString *arg3 = 0 ;
33163 wxString const &arg4_defvalue = wxPyEmptyString ;
33164 wxString *arg4 = (wxString *) &arg4_defvalue ;
33165 wxMenuItem *result;
33166 bool temp3 = false ;
33167 bool temp4 = false ;
33168 PyObject * obj0 = 0 ;
33169 PyObject * obj1 = 0 ;
33170 PyObject * obj2 = 0 ;
33171 PyObject * obj3 = 0 ;
33172 char *kwnames[] = {
33173 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33174 };
33175
33176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33178 if (SWIG_arg_fail(1)) SWIG_fail;
33179 {
33180 arg2 = (int)(SWIG_As_int(obj1));
33181 if (SWIG_arg_fail(2)) SWIG_fail;
33182 }
33183 {
33184 arg3 = wxString_in_helper(obj2);
33185 if (arg3 == NULL) SWIG_fail;
33186 temp3 = true;
33187 }
33188 if (obj3) {
33189 {
33190 arg4 = wxString_in_helper(obj3);
33191 if (arg4 == NULL) SWIG_fail;
33192 temp4 = true;
33193 }
33194 }
33195 {
33196 PyThreadState* __tstate = wxPyBeginAllowThreads();
33197 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33198
33199 wxPyEndAllowThreads(__tstate);
33200 if (PyErr_Occurred()) SWIG_fail;
33201 }
33202 {
33203 resultobj = wxPyMake_wxObject(result, 0);
33204 }
33205 {
33206 if (temp3)
33207 delete arg3;
33208 }
33209 {
33210 if (temp4)
33211 delete arg4;
33212 }
33213 return resultobj;
33214 fail:
33215 {
33216 if (temp3)
33217 delete arg3;
33218 }
33219 {
33220 if (temp4)
33221 delete arg4;
33222 }
33223 return NULL;
33224 }
33225
33226
33227 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33228 PyObject *resultobj;
33229 wxMenu *arg1 = (wxMenu *) 0 ;
33230 int arg2 ;
33231 wxString *arg3 = 0 ;
33232 wxMenu *arg4 = (wxMenu *) 0 ;
33233 wxString const &arg5_defvalue = wxPyEmptyString ;
33234 wxString *arg5 = (wxString *) &arg5_defvalue ;
33235 wxMenuItem *result;
33236 bool temp3 = false ;
33237 bool temp5 = false ;
33238 PyObject * obj0 = 0 ;
33239 PyObject * obj1 = 0 ;
33240 PyObject * obj2 = 0 ;
33241 PyObject * obj3 = 0 ;
33242 PyObject * obj4 = 0 ;
33243 char *kwnames[] = {
33244 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33245 };
33246
33247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33249 if (SWIG_arg_fail(1)) SWIG_fail;
33250 {
33251 arg2 = (int)(SWIG_As_int(obj1));
33252 if (SWIG_arg_fail(2)) SWIG_fail;
33253 }
33254 {
33255 arg3 = wxString_in_helper(obj2);
33256 if (arg3 == NULL) SWIG_fail;
33257 temp3 = true;
33258 }
33259 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33260 if (SWIG_arg_fail(4)) SWIG_fail;
33261 if (obj4) {
33262 {
33263 arg5 = wxString_in_helper(obj4);
33264 if (arg5 == NULL) SWIG_fail;
33265 temp5 = true;
33266 }
33267 }
33268 {
33269 PyThreadState* __tstate = wxPyBeginAllowThreads();
33270 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33271
33272 wxPyEndAllowThreads(__tstate);
33273 if (PyErr_Occurred()) SWIG_fail;
33274 }
33275 {
33276 resultobj = wxPyMake_wxObject(result, 0);
33277 }
33278 {
33279 if (temp3)
33280 delete arg3;
33281 }
33282 {
33283 if (temp5)
33284 delete arg5;
33285 }
33286 return resultobj;
33287 fail:
33288 {
33289 if (temp3)
33290 delete arg3;
33291 }
33292 {
33293 if (temp5)
33294 delete arg5;
33295 }
33296 return NULL;
33297 }
33298
33299
33300 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33301 PyObject *resultobj;
33302 wxMenu *arg1 = (wxMenu *) 0 ;
33303 int arg2 ;
33304 wxMenuItem *result;
33305 PyObject * obj0 = 0 ;
33306 PyObject * obj1 = 0 ;
33307 char *kwnames[] = {
33308 (char *) "self",(char *) "id", NULL
33309 };
33310
33311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33313 if (SWIG_arg_fail(1)) SWIG_fail;
33314 {
33315 arg2 = (int)(SWIG_As_int(obj1));
33316 if (SWIG_arg_fail(2)) SWIG_fail;
33317 }
33318 {
33319 PyThreadState* __tstate = wxPyBeginAllowThreads();
33320 result = (wxMenuItem *)(arg1)->Remove(arg2);
33321
33322 wxPyEndAllowThreads(__tstate);
33323 if (PyErr_Occurred()) SWIG_fail;
33324 }
33325 {
33326 resultobj = wxPyMake_wxObject(result, 0);
33327 }
33328 return resultobj;
33329 fail:
33330 return NULL;
33331 }
33332
33333
33334 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33335 PyObject *resultobj;
33336 wxMenu *arg1 = (wxMenu *) 0 ;
33337 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33338 wxMenuItem *result;
33339 PyObject * obj0 = 0 ;
33340 PyObject * obj1 = 0 ;
33341 char *kwnames[] = {
33342 (char *) "self",(char *) "item", NULL
33343 };
33344
33345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33347 if (SWIG_arg_fail(1)) SWIG_fail;
33348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33349 if (SWIG_arg_fail(2)) SWIG_fail;
33350 {
33351 PyThreadState* __tstate = wxPyBeginAllowThreads();
33352 result = (wxMenuItem *)(arg1)->Remove(arg2);
33353
33354 wxPyEndAllowThreads(__tstate);
33355 if (PyErr_Occurred()) SWIG_fail;
33356 }
33357 {
33358 resultobj = wxPyMake_wxObject(result, 0);
33359 }
33360 return resultobj;
33361 fail:
33362 return NULL;
33363 }
33364
33365
33366 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33367 PyObject *resultobj;
33368 wxMenu *arg1 = (wxMenu *) 0 ;
33369 int arg2 ;
33370 bool result;
33371 PyObject * obj0 = 0 ;
33372 PyObject * obj1 = 0 ;
33373 char *kwnames[] = {
33374 (char *) "self",(char *) "id", NULL
33375 };
33376
33377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33379 if (SWIG_arg_fail(1)) SWIG_fail;
33380 {
33381 arg2 = (int)(SWIG_As_int(obj1));
33382 if (SWIG_arg_fail(2)) SWIG_fail;
33383 }
33384 {
33385 PyThreadState* __tstate = wxPyBeginAllowThreads();
33386 result = (bool)(arg1)->Delete(arg2);
33387
33388 wxPyEndAllowThreads(__tstate);
33389 if (PyErr_Occurred()) SWIG_fail;
33390 }
33391 {
33392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33393 }
33394 return resultobj;
33395 fail:
33396 return NULL;
33397 }
33398
33399
33400 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33401 PyObject *resultobj;
33402 wxMenu *arg1 = (wxMenu *) 0 ;
33403 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33404 bool result;
33405 PyObject * obj0 = 0 ;
33406 PyObject * obj1 = 0 ;
33407 char *kwnames[] = {
33408 (char *) "self",(char *) "item", NULL
33409 };
33410
33411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33413 if (SWIG_arg_fail(1)) SWIG_fail;
33414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33415 if (SWIG_arg_fail(2)) SWIG_fail;
33416 {
33417 PyThreadState* __tstate = wxPyBeginAllowThreads();
33418 result = (bool)(arg1)->Delete(arg2);
33419
33420 wxPyEndAllowThreads(__tstate);
33421 if (PyErr_Occurred()) SWIG_fail;
33422 }
33423 {
33424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33425 }
33426 return resultobj;
33427 fail:
33428 return NULL;
33429 }
33430
33431
33432 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33433 PyObject *resultobj;
33434 wxMenu *arg1 = (wxMenu *) 0 ;
33435 PyObject * obj0 = 0 ;
33436 char *kwnames[] = {
33437 (char *) "self", NULL
33438 };
33439
33440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33442 if (SWIG_arg_fail(1)) SWIG_fail;
33443 {
33444 PyThreadState* __tstate = wxPyBeginAllowThreads();
33445 wxMenu_Destroy(arg1);
33446
33447 wxPyEndAllowThreads(__tstate);
33448 if (PyErr_Occurred()) SWIG_fail;
33449 }
33450 Py_INCREF(Py_None); resultobj = Py_None;
33451 return resultobj;
33452 fail:
33453 return NULL;
33454 }
33455
33456
33457 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33458 PyObject *resultobj;
33459 wxMenu *arg1 = (wxMenu *) 0 ;
33460 int arg2 ;
33461 bool result;
33462 PyObject * obj0 = 0 ;
33463 PyObject * obj1 = 0 ;
33464 char *kwnames[] = {
33465 (char *) "self",(char *) "id", NULL
33466 };
33467
33468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33470 if (SWIG_arg_fail(1)) SWIG_fail;
33471 {
33472 arg2 = (int)(SWIG_As_int(obj1));
33473 if (SWIG_arg_fail(2)) SWIG_fail;
33474 }
33475 {
33476 PyThreadState* __tstate = wxPyBeginAllowThreads();
33477 result = (bool)(arg1)->Destroy(arg2);
33478
33479 wxPyEndAllowThreads(__tstate);
33480 if (PyErr_Occurred()) SWIG_fail;
33481 }
33482 {
33483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33484 }
33485 return resultobj;
33486 fail:
33487 return NULL;
33488 }
33489
33490
33491 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33492 PyObject *resultobj;
33493 wxMenu *arg1 = (wxMenu *) 0 ;
33494 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33495 bool result;
33496 PyObject * obj0 = 0 ;
33497 PyObject * obj1 = 0 ;
33498 char *kwnames[] = {
33499 (char *) "self",(char *) "item", NULL
33500 };
33501
33502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33504 if (SWIG_arg_fail(1)) SWIG_fail;
33505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33506 if (SWIG_arg_fail(2)) SWIG_fail;
33507 {
33508 PyThreadState* __tstate = wxPyBeginAllowThreads();
33509 result = (bool)(arg1)->Destroy(arg2);
33510
33511 wxPyEndAllowThreads(__tstate);
33512 if (PyErr_Occurred()) SWIG_fail;
33513 }
33514 {
33515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33516 }
33517 return resultobj;
33518 fail:
33519 return NULL;
33520 }
33521
33522
33523 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33524 PyObject *resultobj;
33525 wxMenu *arg1 = (wxMenu *) 0 ;
33526 size_t result;
33527 PyObject * obj0 = 0 ;
33528 char *kwnames[] = {
33529 (char *) "self", NULL
33530 };
33531
33532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
33537 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33538
33539 wxPyEndAllowThreads(__tstate);
33540 if (PyErr_Occurred()) SWIG_fail;
33541 }
33542 {
33543 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33544 }
33545 return resultobj;
33546 fail:
33547 return NULL;
33548 }
33549
33550
33551 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33552 PyObject *resultobj;
33553 wxMenu *arg1 = (wxMenu *) 0 ;
33554 PyObject *result;
33555 PyObject * obj0 = 0 ;
33556 char *kwnames[] = {
33557 (char *) "self", NULL
33558 };
33559
33560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33562 if (SWIG_arg_fail(1)) SWIG_fail;
33563 {
33564 PyThreadState* __tstate = wxPyBeginAllowThreads();
33565 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33566
33567 wxPyEndAllowThreads(__tstate);
33568 if (PyErr_Occurred()) SWIG_fail;
33569 }
33570 resultobj = result;
33571 return resultobj;
33572 fail:
33573 return NULL;
33574 }
33575
33576
33577 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33578 PyObject *resultobj;
33579 wxMenu *arg1 = (wxMenu *) 0 ;
33580 wxString *arg2 = 0 ;
33581 int result;
33582 bool temp2 = false ;
33583 PyObject * obj0 = 0 ;
33584 PyObject * obj1 = 0 ;
33585 char *kwnames[] = {
33586 (char *) "self",(char *) "item", NULL
33587 };
33588
33589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33591 if (SWIG_arg_fail(1)) SWIG_fail;
33592 {
33593 arg2 = wxString_in_helper(obj1);
33594 if (arg2 == NULL) SWIG_fail;
33595 temp2 = true;
33596 }
33597 {
33598 PyThreadState* __tstate = wxPyBeginAllowThreads();
33599 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33600
33601 wxPyEndAllowThreads(__tstate);
33602 if (PyErr_Occurred()) SWIG_fail;
33603 }
33604 {
33605 resultobj = SWIG_From_int((int)(result));
33606 }
33607 {
33608 if (temp2)
33609 delete arg2;
33610 }
33611 return resultobj;
33612 fail:
33613 {
33614 if (temp2)
33615 delete arg2;
33616 }
33617 return NULL;
33618 }
33619
33620
33621 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33622 PyObject *resultobj;
33623 wxMenu *arg1 = (wxMenu *) 0 ;
33624 int arg2 ;
33625 wxMenuItem *result;
33626 PyObject * obj0 = 0 ;
33627 PyObject * obj1 = 0 ;
33628 char *kwnames[] = {
33629 (char *) "self",(char *) "id", NULL
33630 };
33631
33632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
33637 if (SWIG_arg_fail(2)) SWIG_fail;
33638 }
33639 {
33640 PyThreadState* __tstate = wxPyBeginAllowThreads();
33641 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33642
33643 wxPyEndAllowThreads(__tstate);
33644 if (PyErr_Occurred()) SWIG_fail;
33645 }
33646 {
33647 resultobj = wxPyMake_wxObject(result, 0);
33648 }
33649 return resultobj;
33650 fail:
33651 return NULL;
33652 }
33653
33654
33655 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33656 PyObject *resultobj;
33657 wxMenu *arg1 = (wxMenu *) 0 ;
33658 size_t arg2 ;
33659 wxMenuItem *result;
33660 PyObject * obj0 = 0 ;
33661 PyObject * obj1 = 0 ;
33662 char *kwnames[] = {
33663 (char *) "self",(char *) "position", NULL
33664 };
33665
33666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33668 if (SWIG_arg_fail(1)) SWIG_fail;
33669 {
33670 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33671 if (SWIG_arg_fail(2)) SWIG_fail;
33672 }
33673 {
33674 PyThreadState* __tstate = wxPyBeginAllowThreads();
33675 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33676
33677 wxPyEndAllowThreads(__tstate);
33678 if (PyErr_Occurred()) SWIG_fail;
33679 }
33680 {
33681 resultobj = wxPyMake_wxObject(result, 0);
33682 }
33683 return resultobj;
33684 fail:
33685 return NULL;
33686 }
33687
33688
33689 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33690 PyObject *resultobj;
33691 wxMenu *arg1 = (wxMenu *) 0 ;
33692 int arg2 ;
33693 bool arg3 ;
33694 PyObject * obj0 = 0 ;
33695 PyObject * obj1 = 0 ;
33696 PyObject * obj2 = 0 ;
33697 char *kwnames[] = {
33698 (char *) "self",(char *) "id",(char *) "enable", NULL
33699 };
33700
33701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33703 if (SWIG_arg_fail(1)) SWIG_fail;
33704 {
33705 arg2 = (int)(SWIG_As_int(obj1));
33706 if (SWIG_arg_fail(2)) SWIG_fail;
33707 }
33708 {
33709 arg3 = (bool)(SWIG_As_bool(obj2));
33710 if (SWIG_arg_fail(3)) SWIG_fail;
33711 }
33712 {
33713 PyThreadState* __tstate = wxPyBeginAllowThreads();
33714 (arg1)->Enable(arg2,arg3);
33715
33716 wxPyEndAllowThreads(__tstate);
33717 if (PyErr_Occurred()) SWIG_fail;
33718 }
33719 Py_INCREF(Py_None); resultobj = Py_None;
33720 return resultobj;
33721 fail:
33722 return NULL;
33723 }
33724
33725
33726 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33727 PyObject *resultobj;
33728 wxMenu *arg1 = (wxMenu *) 0 ;
33729 int arg2 ;
33730 bool result;
33731 PyObject * obj0 = 0 ;
33732 PyObject * obj1 = 0 ;
33733 char *kwnames[] = {
33734 (char *) "self",(char *) "id", NULL
33735 };
33736
33737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33739 if (SWIG_arg_fail(1)) SWIG_fail;
33740 {
33741 arg2 = (int)(SWIG_As_int(obj1));
33742 if (SWIG_arg_fail(2)) SWIG_fail;
33743 }
33744 {
33745 PyThreadState* __tstate = wxPyBeginAllowThreads();
33746 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33747
33748 wxPyEndAllowThreads(__tstate);
33749 if (PyErr_Occurred()) SWIG_fail;
33750 }
33751 {
33752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33753 }
33754 return resultobj;
33755 fail:
33756 return NULL;
33757 }
33758
33759
33760 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33761 PyObject *resultobj;
33762 wxMenu *arg1 = (wxMenu *) 0 ;
33763 int arg2 ;
33764 bool arg3 ;
33765 PyObject * obj0 = 0 ;
33766 PyObject * obj1 = 0 ;
33767 PyObject * obj2 = 0 ;
33768 char *kwnames[] = {
33769 (char *) "self",(char *) "id",(char *) "check", NULL
33770 };
33771
33772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33774 if (SWIG_arg_fail(1)) SWIG_fail;
33775 {
33776 arg2 = (int)(SWIG_As_int(obj1));
33777 if (SWIG_arg_fail(2)) SWIG_fail;
33778 }
33779 {
33780 arg3 = (bool)(SWIG_As_bool(obj2));
33781 if (SWIG_arg_fail(3)) SWIG_fail;
33782 }
33783 {
33784 PyThreadState* __tstate = wxPyBeginAllowThreads();
33785 (arg1)->Check(arg2,arg3);
33786
33787 wxPyEndAllowThreads(__tstate);
33788 if (PyErr_Occurred()) SWIG_fail;
33789 }
33790 Py_INCREF(Py_None); resultobj = Py_None;
33791 return resultobj;
33792 fail:
33793 return NULL;
33794 }
33795
33796
33797 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33798 PyObject *resultobj;
33799 wxMenu *arg1 = (wxMenu *) 0 ;
33800 int arg2 ;
33801 bool result;
33802 PyObject * obj0 = 0 ;
33803 PyObject * obj1 = 0 ;
33804 char *kwnames[] = {
33805 (char *) "self",(char *) "id", NULL
33806 };
33807
33808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33810 if (SWIG_arg_fail(1)) SWIG_fail;
33811 {
33812 arg2 = (int)(SWIG_As_int(obj1));
33813 if (SWIG_arg_fail(2)) SWIG_fail;
33814 }
33815 {
33816 PyThreadState* __tstate = wxPyBeginAllowThreads();
33817 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33818
33819 wxPyEndAllowThreads(__tstate);
33820 if (PyErr_Occurred()) SWIG_fail;
33821 }
33822 {
33823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33824 }
33825 return resultobj;
33826 fail:
33827 return NULL;
33828 }
33829
33830
33831 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33832 PyObject *resultobj;
33833 wxMenu *arg1 = (wxMenu *) 0 ;
33834 int arg2 ;
33835 wxString *arg3 = 0 ;
33836 bool temp3 = false ;
33837 PyObject * obj0 = 0 ;
33838 PyObject * obj1 = 0 ;
33839 PyObject * obj2 = 0 ;
33840 char *kwnames[] = {
33841 (char *) "self",(char *) "id",(char *) "label", NULL
33842 };
33843
33844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33846 if (SWIG_arg_fail(1)) SWIG_fail;
33847 {
33848 arg2 = (int)(SWIG_As_int(obj1));
33849 if (SWIG_arg_fail(2)) SWIG_fail;
33850 }
33851 {
33852 arg3 = wxString_in_helper(obj2);
33853 if (arg3 == NULL) SWIG_fail;
33854 temp3 = true;
33855 }
33856 {
33857 PyThreadState* __tstate = wxPyBeginAllowThreads();
33858 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33859
33860 wxPyEndAllowThreads(__tstate);
33861 if (PyErr_Occurred()) SWIG_fail;
33862 }
33863 Py_INCREF(Py_None); resultobj = Py_None;
33864 {
33865 if (temp3)
33866 delete arg3;
33867 }
33868 return resultobj;
33869 fail:
33870 {
33871 if (temp3)
33872 delete arg3;
33873 }
33874 return NULL;
33875 }
33876
33877
33878 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33879 PyObject *resultobj;
33880 wxMenu *arg1 = (wxMenu *) 0 ;
33881 int arg2 ;
33882 wxString result;
33883 PyObject * obj0 = 0 ;
33884 PyObject * obj1 = 0 ;
33885 char *kwnames[] = {
33886 (char *) "self",(char *) "id", NULL
33887 };
33888
33889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33891 if (SWIG_arg_fail(1)) SWIG_fail;
33892 {
33893 arg2 = (int)(SWIG_As_int(obj1));
33894 if (SWIG_arg_fail(2)) SWIG_fail;
33895 }
33896 {
33897 PyThreadState* __tstate = wxPyBeginAllowThreads();
33898 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33899
33900 wxPyEndAllowThreads(__tstate);
33901 if (PyErr_Occurred()) SWIG_fail;
33902 }
33903 {
33904 #if wxUSE_UNICODE
33905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33906 #else
33907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33908 #endif
33909 }
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33917 PyObject *resultobj;
33918 wxMenu *arg1 = (wxMenu *) 0 ;
33919 int arg2 ;
33920 wxString *arg3 = 0 ;
33921 bool temp3 = false ;
33922 PyObject * obj0 = 0 ;
33923 PyObject * obj1 = 0 ;
33924 PyObject * obj2 = 0 ;
33925 char *kwnames[] = {
33926 (char *) "self",(char *) "id",(char *) "helpString", NULL
33927 };
33928
33929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33931 if (SWIG_arg_fail(1)) SWIG_fail;
33932 {
33933 arg2 = (int)(SWIG_As_int(obj1));
33934 if (SWIG_arg_fail(2)) SWIG_fail;
33935 }
33936 {
33937 arg3 = wxString_in_helper(obj2);
33938 if (arg3 == NULL) SWIG_fail;
33939 temp3 = true;
33940 }
33941 {
33942 PyThreadState* __tstate = wxPyBeginAllowThreads();
33943 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33944
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 Py_INCREF(Py_None); resultobj = Py_None;
33949 {
33950 if (temp3)
33951 delete arg3;
33952 }
33953 return resultobj;
33954 fail:
33955 {
33956 if (temp3)
33957 delete arg3;
33958 }
33959 return NULL;
33960 }
33961
33962
33963 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33964 PyObject *resultobj;
33965 wxMenu *arg1 = (wxMenu *) 0 ;
33966 int arg2 ;
33967 wxString result;
33968 PyObject * obj0 = 0 ;
33969 PyObject * obj1 = 0 ;
33970 char *kwnames[] = {
33971 (char *) "self",(char *) "id", NULL
33972 };
33973
33974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33976 if (SWIG_arg_fail(1)) SWIG_fail;
33977 {
33978 arg2 = (int)(SWIG_As_int(obj1));
33979 if (SWIG_arg_fail(2)) SWIG_fail;
33980 }
33981 {
33982 PyThreadState* __tstate = wxPyBeginAllowThreads();
33983 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33984
33985 wxPyEndAllowThreads(__tstate);
33986 if (PyErr_Occurred()) SWIG_fail;
33987 }
33988 {
33989 #if wxUSE_UNICODE
33990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33991 #else
33992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33993 #endif
33994 }
33995 return resultobj;
33996 fail:
33997 return NULL;
33998 }
33999
34000
34001 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34002 PyObject *resultobj;
34003 wxMenu *arg1 = (wxMenu *) 0 ;
34004 wxString *arg2 = 0 ;
34005 bool temp2 = false ;
34006 PyObject * obj0 = 0 ;
34007 PyObject * obj1 = 0 ;
34008 char *kwnames[] = {
34009 (char *) "self",(char *) "title", NULL
34010 };
34011
34012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34014 if (SWIG_arg_fail(1)) SWIG_fail;
34015 {
34016 arg2 = wxString_in_helper(obj1);
34017 if (arg2 == NULL) SWIG_fail;
34018 temp2 = true;
34019 }
34020 {
34021 PyThreadState* __tstate = wxPyBeginAllowThreads();
34022 (arg1)->SetTitle((wxString const &)*arg2);
34023
34024 wxPyEndAllowThreads(__tstate);
34025 if (PyErr_Occurred()) SWIG_fail;
34026 }
34027 Py_INCREF(Py_None); resultobj = Py_None;
34028 {
34029 if (temp2)
34030 delete arg2;
34031 }
34032 return resultobj;
34033 fail:
34034 {
34035 if (temp2)
34036 delete arg2;
34037 }
34038 return NULL;
34039 }
34040
34041
34042 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34043 PyObject *resultobj;
34044 wxMenu *arg1 = (wxMenu *) 0 ;
34045 wxString result;
34046 PyObject * obj0 = 0 ;
34047 char *kwnames[] = {
34048 (char *) "self", NULL
34049 };
34050
34051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34053 if (SWIG_arg_fail(1)) SWIG_fail;
34054 {
34055 PyThreadState* __tstate = wxPyBeginAllowThreads();
34056 result = ((wxMenu const *)arg1)->GetTitle();
34057
34058 wxPyEndAllowThreads(__tstate);
34059 if (PyErr_Occurred()) SWIG_fail;
34060 }
34061 {
34062 #if wxUSE_UNICODE
34063 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34064 #else
34065 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34066 #endif
34067 }
34068 return resultobj;
34069 fail:
34070 return NULL;
34071 }
34072
34073
34074 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34075 PyObject *resultobj;
34076 wxMenu *arg1 = (wxMenu *) 0 ;
34077 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34078 PyObject * obj0 = 0 ;
34079 PyObject * obj1 = 0 ;
34080 char *kwnames[] = {
34081 (char *) "self",(char *) "handler", NULL
34082 };
34083
34084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34086 if (SWIG_arg_fail(1)) SWIG_fail;
34087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34088 if (SWIG_arg_fail(2)) SWIG_fail;
34089 {
34090 PyThreadState* __tstate = wxPyBeginAllowThreads();
34091 (arg1)->SetEventHandler(arg2);
34092
34093 wxPyEndAllowThreads(__tstate);
34094 if (PyErr_Occurred()) SWIG_fail;
34095 }
34096 Py_INCREF(Py_None); resultobj = Py_None;
34097 return resultobj;
34098 fail:
34099 return NULL;
34100 }
34101
34102
34103 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34104 PyObject *resultobj;
34105 wxMenu *arg1 = (wxMenu *) 0 ;
34106 wxEvtHandler *result;
34107 PyObject * obj0 = 0 ;
34108 char *kwnames[] = {
34109 (char *) "self", NULL
34110 };
34111
34112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34114 if (SWIG_arg_fail(1)) SWIG_fail;
34115 {
34116 PyThreadState* __tstate = wxPyBeginAllowThreads();
34117 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34118
34119 wxPyEndAllowThreads(__tstate);
34120 if (PyErr_Occurred()) SWIG_fail;
34121 }
34122 {
34123 resultobj = wxPyMake_wxObject(result, 0);
34124 }
34125 return resultobj;
34126 fail:
34127 return NULL;
34128 }
34129
34130
34131 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34132 PyObject *resultobj;
34133 wxMenu *arg1 = (wxMenu *) 0 ;
34134 wxWindow *arg2 = (wxWindow *) 0 ;
34135 PyObject * obj0 = 0 ;
34136 PyObject * obj1 = 0 ;
34137 char *kwnames[] = {
34138 (char *) "self",(char *) "win", NULL
34139 };
34140
34141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34143 if (SWIG_arg_fail(1)) SWIG_fail;
34144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34145 if (SWIG_arg_fail(2)) SWIG_fail;
34146 {
34147 PyThreadState* __tstate = wxPyBeginAllowThreads();
34148 (arg1)->SetInvokingWindow(arg2);
34149
34150 wxPyEndAllowThreads(__tstate);
34151 if (PyErr_Occurred()) SWIG_fail;
34152 }
34153 Py_INCREF(Py_None); resultobj = Py_None;
34154 return resultobj;
34155 fail:
34156 return NULL;
34157 }
34158
34159
34160 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34161 PyObject *resultobj;
34162 wxMenu *arg1 = (wxMenu *) 0 ;
34163 wxWindow *result;
34164 PyObject * obj0 = 0 ;
34165 char *kwnames[] = {
34166 (char *) "self", NULL
34167 };
34168
34169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34171 if (SWIG_arg_fail(1)) SWIG_fail;
34172 {
34173 PyThreadState* __tstate = wxPyBeginAllowThreads();
34174 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34175
34176 wxPyEndAllowThreads(__tstate);
34177 if (PyErr_Occurred()) SWIG_fail;
34178 }
34179 {
34180 resultobj = wxPyMake_wxObject(result, 0);
34181 }
34182 return resultobj;
34183 fail:
34184 return NULL;
34185 }
34186
34187
34188 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34189 PyObject *resultobj;
34190 wxMenu *arg1 = (wxMenu *) 0 ;
34191 long result;
34192 PyObject * obj0 = 0 ;
34193 char *kwnames[] = {
34194 (char *) "self", NULL
34195 };
34196
34197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34199 if (SWIG_arg_fail(1)) SWIG_fail;
34200 {
34201 PyThreadState* __tstate = wxPyBeginAllowThreads();
34202 result = (long)((wxMenu const *)arg1)->GetStyle();
34203
34204 wxPyEndAllowThreads(__tstate);
34205 if (PyErr_Occurred()) SWIG_fail;
34206 }
34207 {
34208 resultobj = SWIG_From_long((long)(result));
34209 }
34210 return resultobj;
34211 fail:
34212 return NULL;
34213 }
34214
34215
34216 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34217 PyObject *resultobj;
34218 wxMenu *arg1 = (wxMenu *) 0 ;
34219 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34220 PyObject * obj0 = 0 ;
34221 PyObject * obj1 = 0 ;
34222 char *kwnames[] = {
34223 (char *) "self",(char *) "source", NULL
34224 };
34225
34226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34228 if (SWIG_arg_fail(1)) SWIG_fail;
34229 if (obj1) {
34230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34231 if (SWIG_arg_fail(2)) SWIG_fail;
34232 }
34233 {
34234 PyThreadState* __tstate = wxPyBeginAllowThreads();
34235 (arg1)->UpdateUI(arg2);
34236
34237 wxPyEndAllowThreads(__tstate);
34238 if (PyErr_Occurred()) SWIG_fail;
34239 }
34240 Py_INCREF(Py_None); resultobj = Py_None;
34241 return resultobj;
34242 fail:
34243 return NULL;
34244 }
34245
34246
34247 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34248 PyObject *resultobj;
34249 wxMenu *arg1 = (wxMenu *) 0 ;
34250 wxMenuBar *result;
34251 PyObject * obj0 = 0 ;
34252 char *kwnames[] = {
34253 (char *) "self", NULL
34254 };
34255
34256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34258 if (SWIG_arg_fail(1)) SWIG_fail;
34259 {
34260 PyThreadState* __tstate = wxPyBeginAllowThreads();
34261 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34262
34263 wxPyEndAllowThreads(__tstate);
34264 if (PyErr_Occurred()) SWIG_fail;
34265 }
34266 {
34267 resultobj = wxPyMake_wxObject(result, 0);
34268 }
34269 return resultobj;
34270 fail:
34271 return NULL;
34272 }
34273
34274
34275 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34276 PyObject *resultobj;
34277 wxMenu *arg1 = (wxMenu *) 0 ;
34278 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34279 PyObject * obj0 = 0 ;
34280 PyObject * obj1 = 0 ;
34281 char *kwnames[] = {
34282 (char *) "self",(char *) "menubar", NULL
34283 };
34284
34285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34287 if (SWIG_arg_fail(1)) SWIG_fail;
34288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34289 if (SWIG_arg_fail(2)) SWIG_fail;
34290 {
34291 PyThreadState* __tstate = wxPyBeginAllowThreads();
34292 (arg1)->Attach(arg2);
34293
34294 wxPyEndAllowThreads(__tstate);
34295 if (PyErr_Occurred()) SWIG_fail;
34296 }
34297 Py_INCREF(Py_None); resultobj = Py_None;
34298 return resultobj;
34299 fail:
34300 return NULL;
34301 }
34302
34303
34304 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34305 PyObject *resultobj;
34306 wxMenu *arg1 = (wxMenu *) 0 ;
34307 PyObject * obj0 = 0 ;
34308 char *kwnames[] = {
34309 (char *) "self", NULL
34310 };
34311
34312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34314 if (SWIG_arg_fail(1)) SWIG_fail;
34315 {
34316 PyThreadState* __tstate = wxPyBeginAllowThreads();
34317 (arg1)->Detach();
34318
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 Py_INCREF(Py_None); resultobj = Py_None;
34323 return resultobj;
34324 fail:
34325 return NULL;
34326 }
34327
34328
34329 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34330 PyObject *resultobj;
34331 wxMenu *arg1 = (wxMenu *) 0 ;
34332 bool result;
34333 PyObject * obj0 = 0 ;
34334 char *kwnames[] = {
34335 (char *) "self", NULL
34336 };
34337
34338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34340 if (SWIG_arg_fail(1)) SWIG_fail;
34341 {
34342 PyThreadState* __tstate = wxPyBeginAllowThreads();
34343 result = (bool)((wxMenu const *)arg1)->IsAttached();
34344
34345 wxPyEndAllowThreads(__tstate);
34346 if (PyErr_Occurred()) SWIG_fail;
34347 }
34348 {
34349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34350 }
34351 return resultobj;
34352 fail:
34353 return NULL;
34354 }
34355
34356
34357 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34358 PyObject *resultobj;
34359 wxMenu *arg1 = (wxMenu *) 0 ;
34360 wxMenu *arg2 = (wxMenu *) 0 ;
34361 PyObject * obj0 = 0 ;
34362 PyObject * obj1 = 0 ;
34363 char *kwnames[] = {
34364 (char *) "self",(char *) "parent", NULL
34365 };
34366
34367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34369 if (SWIG_arg_fail(1)) SWIG_fail;
34370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34371 if (SWIG_arg_fail(2)) SWIG_fail;
34372 {
34373 PyThreadState* __tstate = wxPyBeginAllowThreads();
34374 (arg1)->SetParent(arg2);
34375
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 Py_INCREF(Py_None); resultobj = Py_None;
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34387 PyObject *resultobj;
34388 wxMenu *arg1 = (wxMenu *) 0 ;
34389 wxMenu *result;
34390 PyObject * obj0 = 0 ;
34391 char *kwnames[] = {
34392 (char *) "self", NULL
34393 };
34394
34395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34397 if (SWIG_arg_fail(1)) SWIG_fail;
34398 {
34399 PyThreadState* __tstate = wxPyBeginAllowThreads();
34400 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34401
34402 wxPyEndAllowThreads(__tstate);
34403 if (PyErr_Occurred()) SWIG_fail;
34404 }
34405 {
34406 resultobj = wxPyMake_wxObject(result, 0);
34407 }
34408 return resultobj;
34409 fail:
34410 return NULL;
34411 }
34412
34413
34414 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34415 PyObject *obj;
34416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34417 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34418 Py_INCREF(obj);
34419 return Py_BuildValue((char *)"");
34420 }
34421 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34422 PyObject *resultobj;
34423 long arg1 = (long) 0 ;
34424 wxMenuBar *result;
34425 PyObject * obj0 = 0 ;
34426 char *kwnames[] = {
34427 (char *) "style", NULL
34428 };
34429
34430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34431 if (obj0) {
34432 {
34433 arg1 = (long)(SWIG_As_long(obj0));
34434 if (SWIG_arg_fail(1)) SWIG_fail;
34435 }
34436 }
34437 {
34438 if (!wxPyCheckForApp()) SWIG_fail;
34439 PyThreadState* __tstate = wxPyBeginAllowThreads();
34440 result = (wxMenuBar *)new wxMenuBar(arg1);
34441
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34446 return resultobj;
34447 fail:
34448 return NULL;
34449 }
34450
34451
34452 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34453 PyObject *resultobj;
34454 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34455 wxMenu *arg2 = (wxMenu *) 0 ;
34456 wxString *arg3 = 0 ;
34457 bool result;
34458 bool temp3 = false ;
34459 PyObject * obj0 = 0 ;
34460 PyObject * obj1 = 0 ;
34461 PyObject * obj2 = 0 ;
34462 char *kwnames[] = {
34463 (char *) "self",(char *) "menu",(char *) "title", NULL
34464 };
34465
34466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34468 if (SWIG_arg_fail(1)) SWIG_fail;
34469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34470 if (SWIG_arg_fail(2)) SWIG_fail;
34471 {
34472 arg3 = wxString_in_helper(obj2);
34473 if (arg3 == NULL) SWIG_fail;
34474 temp3 = true;
34475 }
34476 {
34477 PyThreadState* __tstate = wxPyBeginAllowThreads();
34478 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34479
34480 wxPyEndAllowThreads(__tstate);
34481 if (PyErr_Occurred()) SWIG_fail;
34482 }
34483 {
34484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34485 }
34486 {
34487 if (temp3)
34488 delete arg3;
34489 }
34490 return resultobj;
34491 fail:
34492 {
34493 if (temp3)
34494 delete arg3;
34495 }
34496 return NULL;
34497 }
34498
34499
34500 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34501 PyObject *resultobj;
34502 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34503 size_t arg2 ;
34504 wxMenu *arg3 = (wxMenu *) 0 ;
34505 wxString *arg4 = 0 ;
34506 bool result;
34507 bool temp4 = false ;
34508 PyObject * obj0 = 0 ;
34509 PyObject * obj1 = 0 ;
34510 PyObject * obj2 = 0 ;
34511 PyObject * obj3 = 0 ;
34512 char *kwnames[] = {
34513 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34514 };
34515
34516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34518 if (SWIG_arg_fail(1)) SWIG_fail;
34519 {
34520 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34521 if (SWIG_arg_fail(2)) SWIG_fail;
34522 }
34523 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34524 if (SWIG_arg_fail(3)) SWIG_fail;
34525 {
34526 arg4 = wxString_in_helper(obj3);
34527 if (arg4 == NULL) SWIG_fail;
34528 temp4 = true;
34529 }
34530 {
34531 PyThreadState* __tstate = wxPyBeginAllowThreads();
34532 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34533
34534 wxPyEndAllowThreads(__tstate);
34535 if (PyErr_Occurred()) SWIG_fail;
34536 }
34537 {
34538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34539 }
34540 {
34541 if (temp4)
34542 delete arg4;
34543 }
34544 return resultobj;
34545 fail:
34546 {
34547 if (temp4)
34548 delete arg4;
34549 }
34550 return NULL;
34551 }
34552
34553
34554 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34555 PyObject *resultobj;
34556 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34557 size_t result;
34558 PyObject * obj0 = 0 ;
34559 char *kwnames[] = {
34560 (char *) "self", NULL
34561 };
34562
34563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34565 if (SWIG_arg_fail(1)) SWIG_fail;
34566 {
34567 PyThreadState* __tstate = wxPyBeginAllowThreads();
34568 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34569
34570 wxPyEndAllowThreads(__tstate);
34571 if (PyErr_Occurred()) SWIG_fail;
34572 }
34573 {
34574 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34575 }
34576 return resultobj;
34577 fail:
34578 return NULL;
34579 }
34580
34581
34582 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34583 PyObject *resultobj;
34584 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34585 size_t arg2 ;
34586 wxMenu *result;
34587 PyObject * obj0 = 0 ;
34588 PyObject * obj1 = 0 ;
34589 char *kwnames[] = {
34590 (char *) "self",(char *) "pos", NULL
34591 };
34592
34593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34595 if (SWIG_arg_fail(1)) SWIG_fail;
34596 {
34597 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34598 if (SWIG_arg_fail(2)) SWIG_fail;
34599 }
34600 {
34601 PyThreadState* __tstate = wxPyBeginAllowThreads();
34602 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34603
34604 wxPyEndAllowThreads(__tstate);
34605 if (PyErr_Occurred()) SWIG_fail;
34606 }
34607 {
34608 resultobj = wxPyMake_wxObject(result, 0);
34609 }
34610 return resultobj;
34611 fail:
34612 return NULL;
34613 }
34614
34615
34616 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34617 PyObject *resultobj;
34618 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34619 size_t arg2 ;
34620 wxMenu *arg3 = (wxMenu *) 0 ;
34621 wxString *arg4 = 0 ;
34622 wxMenu *result;
34623 bool temp4 = false ;
34624 PyObject * obj0 = 0 ;
34625 PyObject * obj1 = 0 ;
34626 PyObject * obj2 = 0 ;
34627 PyObject * obj3 = 0 ;
34628 char *kwnames[] = {
34629 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34630 };
34631
34632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34634 if (SWIG_arg_fail(1)) SWIG_fail;
34635 {
34636 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34637 if (SWIG_arg_fail(2)) SWIG_fail;
34638 }
34639 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34640 if (SWIG_arg_fail(3)) SWIG_fail;
34641 {
34642 arg4 = wxString_in_helper(obj3);
34643 if (arg4 == NULL) SWIG_fail;
34644 temp4 = true;
34645 }
34646 {
34647 PyThreadState* __tstate = wxPyBeginAllowThreads();
34648 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34649
34650 wxPyEndAllowThreads(__tstate);
34651 if (PyErr_Occurred()) SWIG_fail;
34652 }
34653 {
34654 resultobj = wxPyMake_wxObject(result, 0);
34655 }
34656 {
34657 if (temp4)
34658 delete arg4;
34659 }
34660 return resultobj;
34661 fail:
34662 {
34663 if (temp4)
34664 delete arg4;
34665 }
34666 return NULL;
34667 }
34668
34669
34670 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34671 PyObject *resultobj;
34672 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34673 size_t arg2 ;
34674 wxMenu *result;
34675 PyObject * obj0 = 0 ;
34676 PyObject * obj1 = 0 ;
34677 char *kwnames[] = {
34678 (char *) "self",(char *) "pos", NULL
34679 };
34680
34681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34683 if (SWIG_arg_fail(1)) SWIG_fail;
34684 {
34685 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34686 if (SWIG_arg_fail(2)) SWIG_fail;
34687 }
34688 {
34689 PyThreadState* __tstate = wxPyBeginAllowThreads();
34690 result = (wxMenu *)(arg1)->Remove(arg2);
34691
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 {
34696 resultobj = wxPyMake_wxObject(result, 0);
34697 }
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34705 PyObject *resultobj;
34706 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34707 size_t arg2 ;
34708 bool arg3 ;
34709 PyObject * obj0 = 0 ;
34710 PyObject * obj1 = 0 ;
34711 PyObject * obj2 = 0 ;
34712 char *kwnames[] = {
34713 (char *) "self",(char *) "pos",(char *) "enable", NULL
34714 };
34715
34716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34718 if (SWIG_arg_fail(1)) SWIG_fail;
34719 {
34720 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34721 if (SWIG_arg_fail(2)) SWIG_fail;
34722 }
34723 {
34724 arg3 = (bool)(SWIG_As_bool(obj2));
34725 if (SWIG_arg_fail(3)) SWIG_fail;
34726 }
34727 {
34728 PyThreadState* __tstate = wxPyBeginAllowThreads();
34729 (arg1)->EnableTop(arg2,arg3);
34730
34731 wxPyEndAllowThreads(__tstate);
34732 if (PyErr_Occurred()) SWIG_fail;
34733 }
34734 Py_INCREF(Py_None); resultobj = Py_None;
34735 return resultobj;
34736 fail:
34737 return NULL;
34738 }
34739
34740
34741 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34742 PyObject *resultobj;
34743 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34744 size_t arg2 ;
34745 bool result;
34746 PyObject * obj0 = 0 ;
34747 PyObject * obj1 = 0 ;
34748 char *kwnames[] = {
34749 (char *) "self",(char *) "pos", NULL
34750 };
34751
34752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34754 if (SWIG_arg_fail(1)) SWIG_fail;
34755 {
34756 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34757 if (SWIG_arg_fail(2)) SWIG_fail;
34758 }
34759 {
34760 PyThreadState* __tstate = wxPyBeginAllowThreads();
34761 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34762
34763 wxPyEndAllowThreads(__tstate);
34764 if (PyErr_Occurred()) SWIG_fail;
34765 }
34766 {
34767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34768 }
34769 return resultobj;
34770 fail:
34771 return NULL;
34772 }
34773
34774
34775 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34776 PyObject *resultobj;
34777 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34778 size_t arg2 ;
34779 wxString *arg3 = 0 ;
34780 bool temp3 = false ;
34781 PyObject * obj0 = 0 ;
34782 PyObject * obj1 = 0 ;
34783 PyObject * obj2 = 0 ;
34784 char *kwnames[] = {
34785 (char *) "self",(char *) "pos",(char *) "label", NULL
34786 };
34787
34788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34790 if (SWIG_arg_fail(1)) SWIG_fail;
34791 {
34792 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34793 if (SWIG_arg_fail(2)) SWIG_fail;
34794 }
34795 {
34796 arg3 = wxString_in_helper(obj2);
34797 if (arg3 == NULL) SWIG_fail;
34798 temp3 = true;
34799 }
34800 {
34801 PyThreadState* __tstate = wxPyBeginAllowThreads();
34802 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34803
34804 wxPyEndAllowThreads(__tstate);
34805 if (PyErr_Occurred()) SWIG_fail;
34806 }
34807 Py_INCREF(Py_None); resultobj = Py_None;
34808 {
34809 if (temp3)
34810 delete arg3;
34811 }
34812 return resultobj;
34813 fail:
34814 {
34815 if (temp3)
34816 delete arg3;
34817 }
34818 return NULL;
34819 }
34820
34821
34822 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34823 PyObject *resultobj;
34824 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34825 size_t arg2 ;
34826 wxString result;
34827 PyObject * obj0 = 0 ;
34828 PyObject * obj1 = 0 ;
34829 char *kwnames[] = {
34830 (char *) "self",(char *) "pos", NULL
34831 };
34832
34833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34835 if (SWIG_arg_fail(1)) SWIG_fail;
34836 {
34837 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34838 if (SWIG_arg_fail(2)) SWIG_fail;
34839 }
34840 {
34841 PyThreadState* __tstate = wxPyBeginAllowThreads();
34842 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34843
34844 wxPyEndAllowThreads(__tstate);
34845 if (PyErr_Occurred()) SWIG_fail;
34846 }
34847 {
34848 #if wxUSE_UNICODE
34849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34850 #else
34851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34852 #endif
34853 }
34854 return resultobj;
34855 fail:
34856 return NULL;
34857 }
34858
34859
34860 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34861 PyObject *resultobj;
34862 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34863 wxString *arg2 = 0 ;
34864 wxString *arg3 = 0 ;
34865 int result;
34866 bool temp2 = false ;
34867 bool temp3 = false ;
34868 PyObject * obj0 = 0 ;
34869 PyObject * obj1 = 0 ;
34870 PyObject * obj2 = 0 ;
34871 char *kwnames[] = {
34872 (char *) "self",(char *) "menu",(char *) "item", NULL
34873 };
34874
34875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34877 if (SWIG_arg_fail(1)) SWIG_fail;
34878 {
34879 arg2 = wxString_in_helper(obj1);
34880 if (arg2 == NULL) SWIG_fail;
34881 temp2 = true;
34882 }
34883 {
34884 arg3 = wxString_in_helper(obj2);
34885 if (arg3 == NULL) SWIG_fail;
34886 temp3 = true;
34887 }
34888 {
34889 PyThreadState* __tstate = wxPyBeginAllowThreads();
34890 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34891
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 {
34896 resultobj = SWIG_From_int((int)(result));
34897 }
34898 {
34899 if (temp2)
34900 delete arg2;
34901 }
34902 {
34903 if (temp3)
34904 delete arg3;
34905 }
34906 return resultobj;
34907 fail:
34908 {
34909 if (temp2)
34910 delete arg2;
34911 }
34912 {
34913 if (temp3)
34914 delete arg3;
34915 }
34916 return NULL;
34917 }
34918
34919
34920 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34921 PyObject *resultobj;
34922 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34923 int arg2 ;
34924 wxMenuItem *result;
34925 PyObject * obj0 = 0 ;
34926 PyObject * obj1 = 0 ;
34927 char *kwnames[] = {
34928 (char *) "self",(char *) "id", NULL
34929 };
34930
34931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34933 if (SWIG_arg_fail(1)) SWIG_fail;
34934 {
34935 arg2 = (int)(SWIG_As_int(obj1));
34936 if (SWIG_arg_fail(2)) SWIG_fail;
34937 }
34938 {
34939 PyThreadState* __tstate = wxPyBeginAllowThreads();
34940 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34941
34942 wxPyEndAllowThreads(__tstate);
34943 if (PyErr_Occurred()) SWIG_fail;
34944 }
34945 {
34946 resultobj = wxPyMake_wxObject(result, 0);
34947 }
34948 return resultobj;
34949 fail:
34950 return NULL;
34951 }
34952
34953
34954 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34955 PyObject *resultobj;
34956 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34957 wxString *arg2 = 0 ;
34958 int result;
34959 bool temp2 = false ;
34960 PyObject * obj0 = 0 ;
34961 PyObject * obj1 = 0 ;
34962 char *kwnames[] = {
34963 (char *) "self",(char *) "title", NULL
34964 };
34965
34966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34968 if (SWIG_arg_fail(1)) SWIG_fail;
34969 {
34970 arg2 = wxString_in_helper(obj1);
34971 if (arg2 == NULL) SWIG_fail;
34972 temp2 = true;
34973 }
34974 {
34975 PyThreadState* __tstate = wxPyBeginAllowThreads();
34976 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34977
34978 wxPyEndAllowThreads(__tstate);
34979 if (PyErr_Occurred()) SWIG_fail;
34980 }
34981 {
34982 resultobj = SWIG_From_int((int)(result));
34983 }
34984 {
34985 if (temp2)
34986 delete arg2;
34987 }
34988 return resultobj;
34989 fail:
34990 {
34991 if (temp2)
34992 delete arg2;
34993 }
34994 return NULL;
34995 }
34996
34997
34998 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34999 PyObject *resultobj;
35000 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35001 int arg2 ;
35002 bool arg3 ;
35003 PyObject * obj0 = 0 ;
35004 PyObject * obj1 = 0 ;
35005 PyObject * obj2 = 0 ;
35006 char *kwnames[] = {
35007 (char *) "self",(char *) "id",(char *) "enable", NULL
35008 };
35009
35010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35012 if (SWIG_arg_fail(1)) SWIG_fail;
35013 {
35014 arg2 = (int)(SWIG_As_int(obj1));
35015 if (SWIG_arg_fail(2)) SWIG_fail;
35016 }
35017 {
35018 arg3 = (bool)(SWIG_As_bool(obj2));
35019 if (SWIG_arg_fail(3)) SWIG_fail;
35020 }
35021 {
35022 PyThreadState* __tstate = wxPyBeginAllowThreads();
35023 (arg1)->Enable(arg2,arg3);
35024
35025 wxPyEndAllowThreads(__tstate);
35026 if (PyErr_Occurred()) SWIG_fail;
35027 }
35028 Py_INCREF(Py_None); resultobj = Py_None;
35029 return resultobj;
35030 fail:
35031 return NULL;
35032 }
35033
35034
35035 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35036 PyObject *resultobj;
35037 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35038 int arg2 ;
35039 bool arg3 ;
35040 PyObject * obj0 = 0 ;
35041 PyObject * obj1 = 0 ;
35042 PyObject * obj2 = 0 ;
35043 char *kwnames[] = {
35044 (char *) "self",(char *) "id",(char *) "check", NULL
35045 };
35046
35047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35049 if (SWIG_arg_fail(1)) SWIG_fail;
35050 {
35051 arg2 = (int)(SWIG_As_int(obj1));
35052 if (SWIG_arg_fail(2)) SWIG_fail;
35053 }
35054 {
35055 arg3 = (bool)(SWIG_As_bool(obj2));
35056 if (SWIG_arg_fail(3)) SWIG_fail;
35057 }
35058 {
35059 PyThreadState* __tstate = wxPyBeginAllowThreads();
35060 (arg1)->Check(arg2,arg3);
35061
35062 wxPyEndAllowThreads(__tstate);
35063 if (PyErr_Occurred()) SWIG_fail;
35064 }
35065 Py_INCREF(Py_None); resultobj = Py_None;
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35073 PyObject *resultobj;
35074 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35075 int arg2 ;
35076 bool result;
35077 PyObject * obj0 = 0 ;
35078 PyObject * obj1 = 0 ;
35079 char *kwnames[] = {
35080 (char *) "self",(char *) "id", NULL
35081 };
35082
35083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35085 if (SWIG_arg_fail(1)) SWIG_fail;
35086 {
35087 arg2 = (int)(SWIG_As_int(obj1));
35088 if (SWIG_arg_fail(2)) SWIG_fail;
35089 }
35090 {
35091 PyThreadState* __tstate = wxPyBeginAllowThreads();
35092 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35093
35094 wxPyEndAllowThreads(__tstate);
35095 if (PyErr_Occurred()) SWIG_fail;
35096 }
35097 {
35098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35099 }
35100 return resultobj;
35101 fail:
35102 return NULL;
35103 }
35104
35105
35106 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35107 PyObject *resultobj;
35108 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35109 int arg2 ;
35110 bool result;
35111 PyObject * obj0 = 0 ;
35112 PyObject * obj1 = 0 ;
35113 char *kwnames[] = {
35114 (char *) "self",(char *) "id", NULL
35115 };
35116
35117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35119 if (SWIG_arg_fail(1)) SWIG_fail;
35120 {
35121 arg2 = (int)(SWIG_As_int(obj1));
35122 if (SWIG_arg_fail(2)) SWIG_fail;
35123 }
35124 {
35125 PyThreadState* __tstate = wxPyBeginAllowThreads();
35126 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35127
35128 wxPyEndAllowThreads(__tstate);
35129 if (PyErr_Occurred()) SWIG_fail;
35130 }
35131 {
35132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35133 }
35134 return resultobj;
35135 fail:
35136 return NULL;
35137 }
35138
35139
35140 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35141 PyObject *resultobj;
35142 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35143 int arg2 ;
35144 wxString *arg3 = 0 ;
35145 bool temp3 = false ;
35146 PyObject * obj0 = 0 ;
35147 PyObject * obj1 = 0 ;
35148 PyObject * obj2 = 0 ;
35149 char *kwnames[] = {
35150 (char *) "self",(char *) "id",(char *) "label", NULL
35151 };
35152
35153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35155 if (SWIG_arg_fail(1)) SWIG_fail;
35156 {
35157 arg2 = (int)(SWIG_As_int(obj1));
35158 if (SWIG_arg_fail(2)) SWIG_fail;
35159 }
35160 {
35161 arg3 = wxString_in_helper(obj2);
35162 if (arg3 == NULL) SWIG_fail;
35163 temp3 = true;
35164 }
35165 {
35166 PyThreadState* __tstate = wxPyBeginAllowThreads();
35167 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35168
35169 wxPyEndAllowThreads(__tstate);
35170 if (PyErr_Occurred()) SWIG_fail;
35171 }
35172 Py_INCREF(Py_None); resultobj = Py_None;
35173 {
35174 if (temp3)
35175 delete arg3;
35176 }
35177 return resultobj;
35178 fail:
35179 {
35180 if (temp3)
35181 delete arg3;
35182 }
35183 return NULL;
35184 }
35185
35186
35187 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35188 PyObject *resultobj;
35189 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35190 int arg2 ;
35191 wxString result;
35192 PyObject * obj0 = 0 ;
35193 PyObject * obj1 = 0 ;
35194 char *kwnames[] = {
35195 (char *) "self",(char *) "id", NULL
35196 };
35197
35198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35200 if (SWIG_arg_fail(1)) SWIG_fail;
35201 {
35202 arg2 = (int)(SWIG_As_int(obj1));
35203 if (SWIG_arg_fail(2)) SWIG_fail;
35204 }
35205 {
35206 PyThreadState* __tstate = wxPyBeginAllowThreads();
35207 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35208
35209 wxPyEndAllowThreads(__tstate);
35210 if (PyErr_Occurred()) SWIG_fail;
35211 }
35212 {
35213 #if wxUSE_UNICODE
35214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35215 #else
35216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35217 #endif
35218 }
35219 return resultobj;
35220 fail:
35221 return NULL;
35222 }
35223
35224
35225 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35226 PyObject *resultobj;
35227 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35228 int arg2 ;
35229 wxString *arg3 = 0 ;
35230 bool temp3 = false ;
35231 PyObject * obj0 = 0 ;
35232 PyObject * obj1 = 0 ;
35233 PyObject * obj2 = 0 ;
35234 char *kwnames[] = {
35235 (char *) "self",(char *) "id",(char *) "helpString", NULL
35236 };
35237
35238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35240 if (SWIG_arg_fail(1)) SWIG_fail;
35241 {
35242 arg2 = (int)(SWIG_As_int(obj1));
35243 if (SWIG_arg_fail(2)) SWIG_fail;
35244 }
35245 {
35246 arg3 = wxString_in_helper(obj2);
35247 if (arg3 == NULL) SWIG_fail;
35248 temp3 = true;
35249 }
35250 {
35251 PyThreadState* __tstate = wxPyBeginAllowThreads();
35252 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35253
35254 wxPyEndAllowThreads(__tstate);
35255 if (PyErr_Occurred()) SWIG_fail;
35256 }
35257 Py_INCREF(Py_None); resultobj = Py_None;
35258 {
35259 if (temp3)
35260 delete arg3;
35261 }
35262 return resultobj;
35263 fail:
35264 {
35265 if (temp3)
35266 delete arg3;
35267 }
35268 return NULL;
35269 }
35270
35271
35272 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35273 PyObject *resultobj;
35274 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35275 int arg2 ;
35276 wxString result;
35277 PyObject * obj0 = 0 ;
35278 PyObject * obj1 = 0 ;
35279 char *kwnames[] = {
35280 (char *) "self",(char *) "id", NULL
35281 };
35282
35283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35285 if (SWIG_arg_fail(1)) SWIG_fail;
35286 {
35287 arg2 = (int)(SWIG_As_int(obj1));
35288 if (SWIG_arg_fail(2)) SWIG_fail;
35289 }
35290 {
35291 PyThreadState* __tstate = wxPyBeginAllowThreads();
35292 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35293
35294 wxPyEndAllowThreads(__tstate);
35295 if (PyErr_Occurred()) SWIG_fail;
35296 }
35297 {
35298 #if wxUSE_UNICODE
35299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35300 #else
35301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35302 #endif
35303 }
35304 return resultobj;
35305 fail:
35306 return NULL;
35307 }
35308
35309
35310 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35311 PyObject *resultobj;
35312 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35313 wxFrame *result;
35314 PyObject * obj0 = 0 ;
35315 char *kwnames[] = {
35316 (char *) "self", NULL
35317 };
35318
35319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35321 if (SWIG_arg_fail(1)) SWIG_fail;
35322 {
35323 PyThreadState* __tstate = wxPyBeginAllowThreads();
35324 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35325
35326 wxPyEndAllowThreads(__tstate);
35327 if (PyErr_Occurred()) SWIG_fail;
35328 }
35329 {
35330 resultobj = wxPyMake_wxObject(result, 0);
35331 }
35332 return resultobj;
35333 fail:
35334 return NULL;
35335 }
35336
35337
35338 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35339 PyObject *resultobj;
35340 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35341 bool result;
35342 PyObject * obj0 = 0 ;
35343 char *kwnames[] = {
35344 (char *) "self", NULL
35345 };
35346
35347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35349 if (SWIG_arg_fail(1)) SWIG_fail;
35350 {
35351 PyThreadState* __tstate = wxPyBeginAllowThreads();
35352 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35353
35354 wxPyEndAllowThreads(__tstate);
35355 if (PyErr_Occurred()) SWIG_fail;
35356 }
35357 {
35358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35359 }
35360 return resultobj;
35361 fail:
35362 return NULL;
35363 }
35364
35365
35366 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35367 PyObject *resultobj;
35368 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35369 wxFrame *arg2 = (wxFrame *) 0 ;
35370 PyObject * obj0 = 0 ;
35371 PyObject * obj1 = 0 ;
35372 char *kwnames[] = {
35373 (char *) "self",(char *) "frame", NULL
35374 };
35375
35376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35378 if (SWIG_arg_fail(1)) SWIG_fail;
35379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35380 if (SWIG_arg_fail(2)) SWIG_fail;
35381 {
35382 PyThreadState* __tstate = wxPyBeginAllowThreads();
35383 (arg1)->Attach(arg2);
35384
35385 wxPyEndAllowThreads(__tstate);
35386 if (PyErr_Occurred()) SWIG_fail;
35387 }
35388 Py_INCREF(Py_None); resultobj = Py_None;
35389 return resultobj;
35390 fail:
35391 return NULL;
35392 }
35393
35394
35395 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35396 PyObject *resultobj;
35397 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35398 PyObject * obj0 = 0 ;
35399 char *kwnames[] = {
35400 (char *) "self", NULL
35401 };
35402
35403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35405 if (SWIG_arg_fail(1)) SWIG_fail;
35406 {
35407 PyThreadState* __tstate = wxPyBeginAllowThreads();
35408 (arg1)->Detach();
35409
35410 wxPyEndAllowThreads(__tstate);
35411 if (PyErr_Occurred()) SWIG_fail;
35412 }
35413 Py_INCREF(Py_None); resultobj = Py_None;
35414 return resultobj;
35415 fail:
35416 return NULL;
35417 }
35418
35419
35420 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35421 PyObject *obj;
35422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35423 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35424 Py_INCREF(obj);
35425 return Py_BuildValue((char *)"");
35426 }
35427 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35428 PyObject *resultobj;
35429 wxMenu *arg1 = (wxMenu *) NULL ;
35430 int arg2 = (int) wxID_ANY ;
35431 wxString const &arg3_defvalue = wxPyEmptyString ;
35432 wxString *arg3 = (wxString *) &arg3_defvalue ;
35433 wxString const &arg4_defvalue = wxPyEmptyString ;
35434 wxString *arg4 = (wxString *) &arg4_defvalue ;
35435 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35436 wxMenu *arg6 = (wxMenu *) NULL ;
35437 wxMenuItem *result;
35438 bool temp3 = false ;
35439 bool temp4 = false ;
35440 PyObject * obj0 = 0 ;
35441 PyObject * obj1 = 0 ;
35442 PyObject * obj2 = 0 ;
35443 PyObject * obj3 = 0 ;
35444 PyObject * obj4 = 0 ;
35445 PyObject * obj5 = 0 ;
35446 char *kwnames[] = {
35447 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35448 };
35449
35450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35451 if (obj0) {
35452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35453 if (SWIG_arg_fail(1)) SWIG_fail;
35454 }
35455 if (obj1) {
35456 {
35457 arg2 = (int)(SWIG_As_int(obj1));
35458 if (SWIG_arg_fail(2)) SWIG_fail;
35459 }
35460 }
35461 if (obj2) {
35462 {
35463 arg3 = wxString_in_helper(obj2);
35464 if (arg3 == NULL) SWIG_fail;
35465 temp3 = true;
35466 }
35467 }
35468 if (obj3) {
35469 {
35470 arg4 = wxString_in_helper(obj3);
35471 if (arg4 == NULL) SWIG_fail;
35472 temp4 = true;
35473 }
35474 }
35475 if (obj4) {
35476 {
35477 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35478 if (SWIG_arg_fail(5)) SWIG_fail;
35479 }
35480 }
35481 if (obj5) {
35482 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35483 if (SWIG_arg_fail(6)) SWIG_fail;
35484 }
35485 {
35486 PyThreadState* __tstate = wxPyBeginAllowThreads();
35487 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35488
35489 wxPyEndAllowThreads(__tstate);
35490 if (PyErr_Occurred()) SWIG_fail;
35491 }
35492 {
35493 resultobj = wxPyMake_wxObject(result, 1);
35494 }
35495 {
35496 if (temp3)
35497 delete arg3;
35498 }
35499 {
35500 if (temp4)
35501 delete arg4;
35502 }
35503 return resultobj;
35504 fail:
35505 {
35506 if (temp3)
35507 delete arg3;
35508 }
35509 {
35510 if (temp4)
35511 delete arg4;
35512 }
35513 return NULL;
35514 }
35515
35516
35517 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35518 PyObject *resultobj;
35519 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35520 wxMenu *result;
35521 PyObject * obj0 = 0 ;
35522 char *kwnames[] = {
35523 (char *) "self", NULL
35524 };
35525
35526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35528 if (SWIG_arg_fail(1)) SWIG_fail;
35529 {
35530 PyThreadState* __tstate = wxPyBeginAllowThreads();
35531 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35532
35533 wxPyEndAllowThreads(__tstate);
35534 if (PyErr_Occurred()) SWIG_fail;
35535 }
35536 {
35537 resultobj = wxPyMake_wxObject(result, 0);
35538 }
35539 return resultobj;
35540 fail:
35541 return NULL;
35542 }
35543
35544
35545 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35546 PyObject *resultobj;
35547 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35548 wxMenu *arg2 = (wxMenu *) 0 ;
35549 PyObject * obj0 = 0 ;
35550 PyObject * obj1 = 0 ;
35551 char *kwnames[] = {
35552 (char *) "self",(char *) "menu", NULL
35553 };
35554
35555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35557 if (SWIG_arg_fail(1)) SWIG_fail;
35558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35559 if (SWIG_arg_fail(2)) SWIG_fail;
35560 {
35561 PyThreadState* __tstate = wxPyBeginAllowThreads();
35562 (arg1)->SetMenu(arg2);
35563
35564 wxPyEndAllowThreads(__tstate);
35565 if (PyErr_Occurred()) SWIG_fail;
35566 }
35567 Py_INCREF(Py_None); resultobj = Py_None;
35568 return resultobj;
35569 fail:
35570 return NULL;
35571 }
35572
35573
35574 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35575 PyObject *resultobj;
35576 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35577 int arg2 ;
35578 PyObject * obj0 = 0 ;
35579 PyObject * obj1 = 0 ;
35580 char *kwnames[] = {
35581 (char *) "self",(char *) "id", NULL
35582 };
35583
35584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35586 if (SWIG_arg_fail(1)) SWIG_fail;
35587 {
35588 arg2 = (int)(SWIG_As_int(obj1));
35589 if (SWIG_arg_fail(2)) SWIG_fail;
35590 }
35591 {
35592 PyThreadState* __tstate = wxPyBeginAllowThreads();
35593 (arg1)->SetId(arg2);
35594
35595 wxPyEndAllowThreads(__tstate);
35596 if (PyErr_Occurred()) SWIG_fail;
35597 }
35598 Py_INCREF(Py_None); resultobj = Py_None;
35599 return resultobj;
35600 fail:
35601 return NULL;
35602 }
35603
35604
35605 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35606 PyObject *resultobj;
35607 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35608 int result;
35609 PyObject * obj0 = 0 ;
35610 char *kwnames[] = {
35611 (char *) "self", NULL
35612 };
35613
35614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35616 if (SWIG_arg_fail(1)) SWIG_fail;
35617 {
35618 PyThreadState* __tstate = wxPyBeginAllowThreads();
35619 result = (int)((wxMenuItem const *)arg1)->GetId();
35620
35621 wxPyEndAllowThreads(__tstate);
35622 if (PyErr_Occurred()) SWIG_fail;
35623 }
35624 {
35625 resultobj = SWIG_From_int((int)(result));
35626 }
35627 return resultobj;
35628 fail:
35629 return NULL;
35630 }
35631
35632
35633 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35634 PyObject *resultobj;
35635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35636 bool result;
35637 PyObject * obj0 = 0 ;
35638 char *kwnames[] = {
35639 (char *) "self", NULL
35640 };
35641
35642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35644 if (SWIG_arg_fail(1)) SWIG_fail;
35645 {
35646 PyThreadState* __tstate = wxPyBeginAllowThreads();
35647 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35648
35649 wxPyEndAllowThreads(__tstate);
35650 if (PyErr_Occurred()) SWIG_fail;
35651 }
35652 {
35653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35654 }
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35662 PyObject *resultobj;
35663 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35664 wxString *arg2 = 0 ;
35665 bool temp2 = false ;
35666 PyObject * obj0 = 0 ;
35667 PyObject * obj1 = 0 ;
35668 char *kwnames[] = {
35669 (char *) "self",(char *) "str", NULL
35670 };
35671
35672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35674 if (SWIG_arg_fail(1)) SWIG_fail;
35675 {
35676 arg2 = wxString_in_helper(obj1);
35677 if (arg2 == NULL) SWIG_fail;
35678 temp2 = true;
35679 }
35680 {
35681 PyThreadState* __tstate = wxPyBeginAllowThreads();
35682 (arg1)->SetText((wxString const &)*arg2);
35683
35684 wxPyEndAllowThreads(__tstate);
35685 if (PyErr_Occurred()) SWIG_fail;
35686 }
35687 Py_INCREF(Py_None); resultobj = Py_None;
35688 {
35689 if (temp2)
35690 delete arg2;
35691 }
35692 return resultobj;
35693 fail:
35694 {
35695 if (temp2)
35696 delete arg2;
35697 }
35698 return NULL;
35699 }
35700
35701
35702 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35703 PyObject *resultobj;
35704 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35705 wxString result;
35706 PyObject * obj0 = 0 ;
35707 char *kwnames[] = {
35708 (char *) "self", NULL
35709 };
35710
35711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35713 if (SWIG_arg_fail(1)) SWIG_fail;
35714 {
35715 PyThreadState* __tstate = wxPyBeginAllowThreads();
35716 result = ((wxMenuItem const *)arg1)->GetLabel();
35717
35718 wxPyEndAllowThreads(__tstate);
35719 if (PyErr_Occurred()) SWIG_fail;
35720 }
35721 {
35722 #if wxUSE_UNICODE
35723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35724 #else
35725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35726 #endif
35727 }
35728 return resultobj;
35729 fail:
35730 return NULL;
35731 }
35732
35733
35734 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35735 PyObject *resultobj;
35736 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35737 wxString *result;
35738 PyObject * obj0 = 0 ;
35739 char *kwnames[] = {
35740 (char *) "self", NULL
35741 };
35742
35743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35745 if (SWIG_arg_fail(1)) SWIG_fail;
35746 {
35747 PyThreadState* __tstate = wxPyBeginAllowThreads();
35748 {
35749 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35750 result = (wxString *) &_result_ref;
35751 }
35752
35753 wxPyEndAllowThreads(__tstate);
35754 if (PyErr_Occurred()) SWIG_fail;
35755 }
35756 {
35757 #if wxUSE_UNICODE
35758 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35759 #else
35760 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35761 #endif
35762 }
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35770 PyObject *resultobj;
35771 wxString *arg1 = 0 ;
35772 wxString result;
35773 bool temp1 = false ;
35774 PyObject * obj0 = 0 ;
35775 char *kwnames[] = {
35776 (char *) "text", NULL
35777 };
35778
35779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35780 {
35781 arg1 = wxString_in_helper(obj0);
35782 if (arg1 == NULL) SWIG_fail;
35783 temp1 = true;
35784 }
35785 {
35786 PyThreadState* __tstate = wxPyBeginAllowThreads();
35787 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35788
35789 wxPyEndAllowThreads(__tstate);
35790 if (PyErr_Occurred()) SWIG_fail;
35791 }
35792 {
35793 #if wxUSE_UNICODE
35794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35795 #else
35796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35797 #endif
35798 }
35799 {
35800 if (temp1)
35801 delete arg1;
35802 }
35803 return resultobj;
35804 fail:
35805 {
35806 if (temp1)
35807 delete arg1;
35808 }
35809 return NULL;
35810 }
35811
35812
35813 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35814 PyObject *resultobj;
35815 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35816 wxItemKind result;
35817 PyObject * obj0 = 0 ;
35818 char *kwnames[] = {
35819 (char *) "self", NULL
35820 };
35821
35822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35824 if (SWIG_arg_fail(1)) SWIG_fail;
35825 {
35826 PyThreadState* __tstate = wxPyBeginAllowThreads();
35827 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35828
35829 wxPyEndAllowThreads(__tstate);
35830 if (PyErr_Occurred()) SWIG_fail;
35831 }
35832 resultobj = SWIG_From_int((result));
35833 return resultobj;
35834 fail:
35835 return NULL;
35836 }
35837
35838
35839 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35840 PyObject *resultobj;
35841 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35842 wxItemKind arg2 ;
35843 PyObject * obj0 = 0 ;
35844 PyObject * obj1 = 0 ;
35845 char *kwnames[] = {
35846 (char *) "self",(char *) "kind", NULL
35847 };
35848
35849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35851 if (SWIG_arg_fail(1)) SWIG_fail;
35852 {
35853 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35854 if (SWIG_arg_fail(2)) SWIG_fail;
35855 }
35856 {
35857 PyThreadState* __tstate = wxPyBeginAllowThreads();
35858 (arg1)->SetKind((wxItemKind )arg2);
35859
35860 wxPyEndAllowThreads(__tstate);
35861 if (PyErr_Occurred()) SWIG_fail;
35862 }
35863 Py_INCREF(Py_None); resultobj = Py_None;
35864 return resultobj;
35865 fail:
35866 return NULL;
35867 }
35868
35869
35870 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35871 PyObject *resultobj;
35872 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35873 bool arg2 ;
35874 PyObject * obj0 = 0 ;
35875 PyObject * obj1 = 0 ;
35876 char *kwnames[] = {
35877 (char *) "self",(char *) "checkable", NULL
35878 };
35879
35880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) 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 arg2 = (bool)(SWIG_As_bool(obj1));
35885 if (SWIG_arg_fail(2)) SWIG_fail;
35886 }
35887 {
35888 PyThreadState* __tstate = wxPyBeginAllowThreads();
35889 (arg1)->SetCheckable(arg2);
35890
35891 wxPyEndAllowThreads(__tstate);
35892 if (PyErr_Occurred()) SWIG_fail;
35893 }
35894 Py_INCREF(Py_None); resultobj = Py_None;
35895 return resultobj;
35896 fail:
35897 return NULL;
35898 }
35899
35900
35901 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35902 PyObject *resultobj;
35903 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35904 bool result;
35905 PyObject * obj0 = 0 ;
35906 char *kwnames[] = {
35907 (char *) "self", NULL
35908 };
35909
35910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35912 if (SWIG_arg_fail(1)) SWIG_fail;
35913 {
35914 PyThreadState* __tstate = wxPyBeginAllowThreads();
35915 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35916
35917 wxPyEndAllowThreads(__tstate);
35918 if (PyErr_Occurred()) SWIG_fail;
35919 }
35920 {
35921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35922 }
35923 return resultobj;
35924 fail:
35925 return NULL;
35926 }
35927
35928
35929 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35930 PyObject *resultobj;
35931 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35932 bool result;
35933 PyObject * obj0 = 0 ;
35934 char *kwnames[] = {
35935 (char *) "self", NULL
35936 };
35937
35938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35940 if (SWIG_arg_fail(1)) SWIG_fail;
35941 {
35942 PyThreadState* __tstate = wxPyBeginAllowThreads();
35943 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35944
35945 wxPyEndAllowThreads(__tstate);
35946 if (PyErr_Occurred()) SWIG_fail;
35947 }
35948 {
35949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35950 }
35951 return resultobj;
35952 fail:
35953 return NULL;
35954 }
35955
35956
35957 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35958 PyObject *resultobj;
35959 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35960 wxMenu *arg2 = (wxMenu *) 0 ;
35961 PyObject * obj0 = 0 ;
35962 PyObject * obj1 = 0 ;
35963 char *kwnames[] = {
35964 (char *) "self",(char *) "menu", NULL
35965 };
35966
35967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35969 if (SWIG_arg_fail(1)) SWIG_fail;
35970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35971 if (SWIG_arg_fail(2)) SWIG_fail;
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 (arg1)->SetSubMenu(arg2);
35975
35976 wxPyEndAllowThreads(__tstate);
35977 if (PyErr_Occurred()) SWIG_fail;
35978 }
35979 Py_INCREF(Py_None); resultobj = Py_None;
35980 return resultobj;
35981 fail:
35982 return NULL;
35983 }
35984
35985
35986 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35987 PyObject *resultobj;
35988 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35989 wxMenu *result;
35990 PyObject * obj0 = 0 ;
35991 char *kwnames[] = {
35992 (char *) "self", NULL
35993 };
35994
35995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35997 if (SWIG_arg_fail(1)) SWIG_fail;
35998 {
35999 PyThreadState* __tstate = wxPyBeginAllowThreads();
36000 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36001
36002 wxPyEndAllowThreads(__tstate);
36003 if (PyErr_Occurred()) SWIG_fail;
36004 }
36005 {
36006 resultobj = wxPyMake_wxObject(result, 0);
36007 }
36008 return resultobj;
36009 fail:
36010 return NULL;
36011 }
36012
36013
36014 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36015 PyObject *resultobj;
36016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36017 bool arg2 = (bool) true ;
36018 PyObject * obj0 = 0 ;
36019 PyObject * obj1 = 0 ;
36020 char *kwnames[] = {
36021 (char *) "self",(char *) "enable", NULL
36022 };
36023
36024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36026 if (SWIG_arg_fail(1)) SWIG_fail;
36027 if (obj1) {
36028 {
36029 arg2 = (bool)(SWIG_As_bool(obj1));
36030 if (SWIG_arg_fail(2)) SWIG_fail;
36031 }
36032 }
36033 {
36034 PyThreadState* __tstate = wxPyBeginAllowThreads();
36035 (arg1)->Enable(arg2);
36036
36037 wxPyEndAllowThreads(__tstate);
36038 if (PyErr_Occurred()) SWIG_fail;
36039 }
36040 Py_INCREF(Py_None); resultobj = Py_None;
36041 return resultobj;
36042 fail:
36043 return NULL;
36044 }
36045
36046
36047 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36048 PyObject *resultobj;
36049 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36050 bool result;
36051 PyObject * obj0 = 0 ;
36052 char *kwnames[] = {
36053 (char *) "self", NULL
36054 };
36055
36056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36058 if (SWIG_arg_fail(1)) SWIG_fail;
36059 {
36060 PyThreadState* __tstate = wxPyBeginAllowThreads();
36061 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36062
36063 wxPyEndAllowThreads(__tstate);
36064 if (PyErr_Occurred()) SWIG_fail;
36065 }
36066 {
36067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36068 }
36069 return resultobj;
36070 fail:
36071 return NULL;
36072 }
36073
36074
36075 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36076 PyObject *resultobj;
36077 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36078 bool arg2 = (bool) true ;
36079 PyObject * obj0 = 0 ;
36080 PyObject * obj1 = 0 ;
36081 char *kwnames[] = {
36082 (char *) "self",(char *) "check", NULL
36083 };
36084
36085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36087 if (SWIG_arg_fail(1)) SWIG_fail;
36088 if (obj1) {
36089 {
36090 arg2 = (bool)(SWIG_As_bool(obj1));
36091 if (SWIG_arg_fail(2)) SWIG_fail;
36092 }
36093 }
36094 {
36095 PyThreadState* __tstate = wxPyBeginAllowThreads();
36096 (arg1)->Check(arg2);
36097
36098 wxPyEndAllowThreads(__tstate);
36099 if (PyErr_Occurred()) SWIG_fail;
36100 }
36101 Py_INCREF(Py_None); resultobj = Py_None;
36102 return resultobj;
36103 fail:
36104 return NULL;
36105 }
36106
36107
36108 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36109 PyObject *resultobj;
36110 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36111 bool result;
36112 PyObject * obj0 = 0 ;
36113 char *kwnames[] = {
36114 (char *) "self", NULL
36115 };
36116
36117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36119 if (SWIG_arg_fail(1)) SWIG_fail;
36120 {
36121 PyThreadState* __tstate = wxPyBeginAllowThreads();
36122 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36123
36124 wxPyEndAllowThreads(__tstate);
36125 if (PyErr_Occurred()) SWIG_fail;
36126 }
36127 {
36128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36129 }
36130 return resultobj;
36131 fail:
36132 return NULL;
36133 }
36134
36135
36136 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36137 PyObject *resultobj;
36138 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36139 PyObject * obj0 = 0 ;
36140 char *kwnames[] = {
36141 (char *) "self", NULL
36142 };
36143
36144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36146 if (SWIG_arg_fail(1)) SWIG_fail;
36147 {
36148 PyThreadState* __tstate = wxPyBeginAllowThreads();
36149 (arg1)->Toggle();
36150
36151 wxPyEndAllowThreads(__tstate);
36152 if (PyErr_Occurred()) SWIG_fail;
36153 }
36154 Py_INCREF(Py_None); resultobj = Py_None;
36155 return resultobj;
36156 fail:
36157 return NULL;
36158 }
36159
36160
36161 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36162 PyObject *resultobj;
36163 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36164 wxString *arg2 = 0 ;
36165 bool temp2 = false ;
36166 PyObject * obj0 = 0 ;
36167 PyObject * obj1 = 0 ;
36168 char *kwnames[] = {
36169 (char *) "self",(char *) "str", NULL
36170 };
36171
36172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36174 if (SWIG_arg_fail(1)) SWIG_fail;
36175 {
36176 arg2 = wxString_in_helper(obj1);
36177 if (arg2 == NULL) SWIG_fail;
36178 temp2 = true;
36179 }
36180 {
36181 PyThreadState* __tstate = wxPyBeginAllowThreads();
36182 (arg1)->SetHelp((wxString const &)*arg2);
36183
36184 wxPyEndAllowThreads(__tstate);
36185 if (PyErr_Occurred()) SWIG_fail;
36186 }
36187 Py_INCREF(Py_None); resultobj = Py_None;
36188 {
36189 if (temp2)
36190 delete arg2;
36191 }
36192 return resultobj;
36193 fail:
36194 {
36195 if (temp2)
36196 delete arg2;
36197 }
36198 return NULL;
36199 }
36200
36201
36202 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36203 PyObject *resultobj;
36204 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36205 wxString *result;
36206 PyObject * obj0 = 0 ;
36207 char *kwnames[] = {
36208 (char *) "self", NULL
36209 };
36210
36211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36213 if (SWIG_arg_fail(1)) SWIG_fail;
36214 {
36215 PyThreadState* __tstate = wxPyBeginAllowThreads();
36216 {
36217 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36218 result = (wxString *) &_result_ref;
36219 }
36220
36221 wxPyEndAllowThreads(__tstate);
36222 if (PyErr_Occurred()) SWIG_fail;
36223 }
36224 {
36225 #if wxUSE_UNICODE
36226 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36227 #else
36228 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36229 #endif
36230 }
36231 return resultobj;
36232 fail:
36233 return NULL;
36234 }
36235
36236
36237 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36238 PyObject *resultobj;
36239 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36240 wxAcceleratorEntry *result;
36241 PyObject * obj0 = 0 ;
36242 char *kwnames[] = {
36243 (char *) "self", NULL
36244 };
36245
36246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36248 if (SWIG_arg_fail(1)) SWIG_fail;
36249 {
36250 PyThreadState* __tstate = wxPyBeginAllowThreads();
36251 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36252
36253 wxPyEndAllowThreads(__tstate);
36254 if (PyErr_Occurred()) SWIG_fail;
36255 }
36256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36257 return resultobj;
36258 fail:
36259 return NULL;
36260 }
36261
36262
36263 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36264 PyObject *resultobj;
36265 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36266 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36267 PyObject * obj0 = 0 ;
36268 PyObject * obj1 = 0 ;
36269 char *kwnames[] = {
36270 (char *) "self",(char *) "accel", NULL
36271 };
36272
36273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36275 if (SWIG_arg_fail(1)) SWIG_fail;
36276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36277 if (SWIG_arg_fail(2)) SWIG_fail;
36278 {
36279 PyThreadState* __tstate = wxPyBeginAllowThreads();
36280 (arg1)->SetAccel(arg2);
36281
36282 wxPyEndAllowThreads(__tstate);
36283 if (PyErr_Occurred()) SWIG_fail;
36284 }
36285 Py_INCREF(Py_None); resultobj = Py_None;
36286 return resultobj;
36287 fail:
36288 return NULL;
36289 }
36290
36291
36292 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36293 PyObject *resultobj;
36294 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36295 wxFont *arg2 = 0 ;
36296 PyObject * obj0 = 0 ;
36297 PyObject * obj1 = 0 ;
36298 char *kwnames[] = {
36299 (char *) "self",(char *) "font", NULL
36300 };
36301
36302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36304 if (SWIG_arg_fail(1)) SWIG_fail;
36305 {
36306 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36307 if (SWIG_arg_fail(2)) SWIG_fail;
36308 if (arg2 == NULL) {
36309 SWIG_null_ref("wxFont");
36310 }
36311 if (SWIG_arg_fail(2)) SWIG_fail;
36312 }
36313 {
36314 PyThreadState* __tstate = wxPyBeginAllowThreads();
36315 (arg1)->SetFont((wxFont const &)*arg2);
36316
36317 wxPyEndAllowThreads(__tstate);
36318 if (PyErr_Occurred()) SWIG_fail;
36319 }
36320 Py_INCREF(Py_None); resultobj = Py_None;
36321 return resultobj;
36322 fail:
36323 return NULL;
36324 }
36325
36326
36327 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36328 PyObject *resultobj;
36329 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36330 wxFont result;
36331 PyObject * obj0 = 0 ;
36332 char *kwnames[] = {
36333 (char *) "self", NULL
36334 };
36335
36336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36338 if (SWIG_arg_fail(1)) SWIG_fail;
36339 {
36340 PyThreadState* __tstate = wxPyBeginAllowThreads();
36341 result = (arg1)->GetFont();
36342
36343 wxPyEndAllowThreads(__tstate);
36344 if (PyErr_Occurred()) SWIG_fail;
36345 }
36346 {
36347 wxFont * resultptr;
36348 resultptr = new wxFont((wxFont &)(result));
36349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36350 }
36351 return resultobj;
36352 fail:
36353 return NULL;
36354 }
36355
36356
36357 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36358 PyObject *resultobj;
36359 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36360 wxColour *arg2 = 0 ;
36361 wxColour temp2 ;
36362 PyObject * obj0 = 0 ;
36363 PyObject * obj1 = 0 ;
36364 char *kwnames[] = {
36365 (char *) "self",(char *) "colText", NULL
36366 };
36367
36368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36370 if (SWIG_arg_fail(1)) SWIG_fail;
36371 {
36372 arg2 = &temp2;
36373 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36374 }
36375 {
36376 PyThreadState* __tstate = wxPyBeginAllowThreads();
36377 (arg1)->SetTextColour((wxColour const &)*arg2);
36378
36379 wxPyEndAllowThreads(__tstate);
36380 if (PyErr_Occurred()) SWIG_fail;
36381 }
36382 Py_INCREF(Py_None); resultobj = Py_None;
36383 return resultobj;
36384 fail:
36385 return NULL;
36386 }
36387
36388
36389 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36390 PyObject *resultobj;
36391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36392 wxColour result;
36393 PyObject * obj0 = 0 ;
36394 char *kwnames[] = {
36395 (char *) "self", NULL
36396 };
36397
36398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36400 if (SWIG_arg_fail(1)) SWIG_fail;
36401 {
36402 PyThreadState* __tstate = wxPyBeginAllowThreads();
36403 result = (arg1)->GetTextColour();
36404
36405 wxPyEndAllowThreads(__tstate);
36406 if (PyErr_Occurred()) SWIG_fail;
36407 }
36408 {
36409 wxColour * resultptr;
36410 resultptr = new wxColour((wxColour &)(result));
36411 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36412 }
36413 return resultobj;
36414 fail:
36415 return NULL;
36416 }
36417
36418
36419 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36420 PyObject *resultobj;
36421 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36422 wxColour *arg2 = 0 ;
36423 wxColour temp2 ;
36424 PyObject * obj0 = 0 ;
36425 PyObject * obj1 = 0 ;
36426 char *kwnames[] = {
36427 (char *) "self",(char *) "colBack", NULL
36428 };
36429
36430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36432 if (SWIG_arg_fail(1)) SWIG_fail;
36433 {
36434 arg2 = &temp2;
36435 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36436 }
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36440
36441 wxPyEndAllowThreads(__tstate);
36442 if (PyErr_Occurred()) SWIG_fail;
36443 }
36444 Py_INCREF(Py_None); resultobj = Py_None;
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36452 PyObject *resultobj;
36453 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36454 wxColour result;
36455 PyObject * obj0 = 0 ;
36456 char *kwnames[] = {
36457 (char *) "self", NULL
36458 };
36459
36460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36462 if (SWIG_arg_fail(1)) SWIG_fail;
36463 {
36464 PyThreadState* __tstate = wxPyBeginAllowThreads();
36465 result = (arg1)->GetBackgroundColour();
36466
36467 wxPyEndAllowThreads(__tstate);
36468 if (PyErr_Occurred()) SWIG_fail;
36469 }
36470 {
36471 wxColour * resultptr;
36472 resultptr = new wxColour((wxColour &)(result));
36473 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36474 }
36475 return resultobj;
36476 fail:
36477 return NULL;
36478 }
36479
36480
36481 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36482 PyObject *resultobj;
36483 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36484 wxBitmap *arg2 = 0 ;
36485 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36486 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36487 PyObject * obj0 = 0 ;
36488 PyObject * obj1 = 0 ;
36489 PyObject * obj2 = 0 ;
36490 char *kwnames[] = {
36491 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36492 };
36493
36494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36496 if (SWIG_arg_fail(1)) SWIG_fail;
36497 {
36498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36499 if (SWIG_arg_fail(2)) SWIG_fail;
36500 if (arg2 == NULL) {
36501 SWIG_null_ref("wxBitmap");
36502 }
36503 if (SWIG_arg_fail(2)) SWIG_fail;
36504 }
36505 if (obj2) {
36506 {
36507 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36508 if (SWIG_arg_fail(3)) SWIG_fail;
36509 if (arg3 == NULL) {
36510 SWIG_null_ref("wxBitmap");
36511 }
36512 if (SWIG_arg_fail(3)) SWIG_fail;
36513 }
36514 }
36515 {
36516 PyThreadState* __tstate = wxPyBeginAllowThreads();
36517 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36518
36519 wxPyEndAllowThreads(__tstate);
36520 if (PyErr_Occurred()) SWIG_fail;
36521 }
36522 Py_INCREF(Py_None); resultobj = Py_None;
36523 return resultobj;
36524 fail:
36525 return NULL;
36526 }
36527
36528
36529 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36530 PyObject *resultobj;
36531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36532 wxBitmap *arg2 = 0 ;
36533 PyObject * obj0 = 0 ;
36534 PyObject * obj1 = 0 ;
36535 char *kwnames[] = {
36536 (char *) "self",(char *) "bmpDisabled", NULL
36537 };
36538
36539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36541 if (SWIG_arg_fail(1)) SWIG_fail;
36542 {
36543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36544 if (SWIG_arg_fail(2)) SWIG_fail;
36545 if (arg2 == NULL) {
36546 SWIG_null_ref("wxBitmap");
36547 }
36548 if (SWIG_arg_fail(2)) SWIG_fail;
36549 }
36550 {
36551 PyThreadState* __tstate = wxPyBeginAllowThreads();
36552 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36553
36554 wxPyEndAllowThreads(__tstate);
36555 if (PyErr_Occurred()) SWIG_fail;
36556 }
36557 Py_INCREF(Py_None); resultobj = Py_None;
36558 return resultobj;
36559 fail:
36560 return NULL;
36561 }
36562
36563
36564 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36565 PyObject *resultobj;
36566 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36567 wxBitmap *result;
36568 PyObject * obj0 = 0 ;
36569 char *kwnames[] = {
36570 (char *) "self", NULL
36571 };
36572
36573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36575 if (SWIG_arg_fail(1)) SWIG_fail;
36576 {
36577 PyThreadState* __tstate = wxPyBeginAllowThreads();
36578 {
36579 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
36580 result = (wxBitmap *) &_result_ref;
36581 }
36582
36583 wxPyEndAllowThreads(__tstate);
36584 if (PyErr_Occurred()) SWIG_fail;
36585 }
36586 {
36587 wxBitmap* resultptr = new wxBitmap(*result);
36588 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36589 }
36590 return resultobj;
36591 fail:
36592 return NULL;
36593 }
36594
36595
36596 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36597 PyObject *resultobj;
36598 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36599 int arg2 ;
36600 PyObject * obj0 = 0 ;
36601 PyObject * obj1 = 0 ;
36602 char *kwnames[] = {
36603 (char *) "self",(char *) "nWidth", NULL
36604 };
36605
36606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36608 if (SWIG_arg_fail(1)) SWIG_fail;
36609 {
36610 arg2 = (int)(SWIG_As_int(obj1));
36611 if (SWIG_arg_fail(2)) SWIG_fail;
36612 }
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 (arg1)->SetMarginWidth(arg2);
36616
36617 wxPyEndAllowThreads(__tstate);
36618 if (PyErr_Occurred()) SWIG_fail;
36619 }
36620 Py_INCREF(Py_None); resultobj = Py_None;
36621 return resultobj;
36622 fail:
36623 return NULL;
36624 }
36625
36626
36627 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36628 PyObject *resultobj;
36629 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36630 int result;
36631 PyObject * obj0 = 0 ;
36632 char *kwnames[] = {
36633 (char *) "self", NULL
36634 };
36635
36636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36638 if (SWIG_arg_fail(1)) SWIG_fail;
36639 {
36640 PyThreadState* __tstate = wxPyBeginAllowThreads();
36641 result = (int)(arg1)->GetMarginWidth();
36642
36643 wxPyEndAllowThreads(__tstate);
36644 if (PyErr_Occurred()) SWIG_fail;
36645 }
36646 {
36647 resultobj = SWIG_From_int((int)(result));
36648 }
36649 return resultobj;
36650 fail:
36651 return NULL;
36652 }
36653
36654
36655 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36656 PyObject *resultobj;
36657 int result;
36658 char *kwnames[] = {
36659 NULL
36660 };
36661
36662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36663 {
36664 PyThreadState* __tstate = wxPyBeginAllowThreads();
36665 result = (int)wxMenuItem::GetDefaultMarginWidth();
36666
36667 wxPyEndAllowThreads(__tstate);
36668 if (PyErr_Occurred()) SWIG_fail;
36669 }
36670 {
36671 resultobj = SWIG_From_int((int)(result));
36672 }
36673 return resultobj;
36674 fail:
36675 return NULL;
36676 }
36677
36678
36679 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36680 PyObject *resultobj;
36681 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36682 bool result;
36683 PyObject * obj0 = 0 ;
36684 char *kwnames[] = {
36685 (char *) "self", NULL
36686 };
36687
36688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36690 if (SWIG_arg_fail(1)) SWIG_fail;
36691 {
36692 PyThreadState* __tstate = wxPyBeginAllowThreads();
36693 result = (bool)(arg1)->IsOwnerDrawn();
36694
36695 wxPyEndAllowThreads(__tstate);
36696 if (PyErr_Occurred()) SWIG_fail;
36697 }
36698 {
36699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36700 }
36701 return resultobj;
36702 fail:
36703 return NULL;
36704 }
36705
36706
36707 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36708 PyObject *resultobj;
36709 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36710 bool arg2 = (bool) true ;
36711 PyObject * obj0 = 0 ;
36712 PyObject * obj1 = 0 ;
36713 char *kwnames[] = {
36714 (char *) "self",(char *) "ownerDrawn", NULL
36715 };
36716
36717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36719 if (SWIG_arg_fail(1)) SWIG_fail;
36720 if (obj1) {
36721 {
36722 arg2 = (bool)(SWIG_As_bool(obj1));
36723 if (SWIG_arg_fail(2)) SWIG_fail;
36724 }
36725 }
36726 {
36727 PyThreadState* __tstate = wxPyBeginAllowThreads();
36728 (arg1)->SetOwnerDrawn(arg2);
36729
36730 wxPyEndAllowThreads(__tstate);
36731 if (PyErr_Occurred()) SWIG_fail;
36732 }
36733 Py_INCREF(Py_None); resultobj = Py_None;
36734 return resultobj;
36735 fail:
36736 return NULL;
36737 }
36738
36739
36740 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36741 PyObject *resultobj;
36742 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36743 PyObject * obj0 = 0 ;
36744 char *kwnames[] = {
36745 (char *) "self", NULL
36746 };
36747
36748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36750 if (SWIG_arg_fail(1)) SWIG_fail;
36751 {
36752 PyThreadState* __tstate = wxPyBeginAllowThreads();
36753 (arg1)->ResetOwnerDrawn();
36754
36755 wxPyEndAllowThreads(__tstate);
36756 if (PyErr_Occurred()) SWIG_fail;
36757 }
36758 Py_INCREF(Py_None); resultobj = Py_None;
36759 return resultobj;
36760 fail:
36761 return NULL;
36762 }
36763
36764
36765 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36766 PyObject *resultobj;
36767 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36768 wxBitmap *arg2 = 0 ;
36769 PyObject * obj0 = 0 ;
36770 PyObject * obj1 = 0 ;
36771 char *kwnames[] = {
36772 (char *) "self",(char *) "bitmap", NULL
36773 };
36774
36775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36777 if (SWIG_arg_fail(1)) SWIG_fail;
36778 {
36779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36780 if (SWIG_arg_fail(2)) SWIG_fail;
36781 if (arg2 == NULL) {
36782 SWIG_null_ref("wxBitmap");
36783 }
36784 if (SWIG_arg_fail(2)) SWIG_fail;
36785 }
36786 {
36787 PyThreadState* __tstate = wxPyBeginAllowThreads();
36788 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36789
36790 wxPyEndAllowThreads(__tstate);
36791 if (PyErr_Occurred()) SWIG_fail;
36792 }
36793 Py_INCREF(Py_None); resultobj = Py_None;
36794 return resultobj;
36795 fail:
36796 return NULL;
36797 }
36798
36799
36800 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36801 PyObject *resultobj;
36802 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36803 wxBitmap *result;
36804 PyObject * obj0 = 0 ;
36805 char *kwnames[] = {
36806 (char *) "self", NULL
36807 };
36808
36809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36811 if (SWIG_arg_fail(1)) SWIG_fail;
36812 {
36813 PyThreadState* __tstate = wxPyBeginAllowThreads();
36814 {
36815 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36816 result = (wxBitmap *) &_result_ref;
36817 }
36818
36819 wxPyEndAllowThreads(__tstate);
36820 if (PyErr_Occurred()) SWIG_fail;
36821 }
36822 {
36823 wxBitmap* resultptr = new wxBitmap(*result);
36824 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36825 }
36826 return resultobj;
36827 fail:
36828 return NULL;
36829 }
36830
36831
36832 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36833 PyObject *obj;
36834 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36835 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36836 Py_INCREF(obj);
36837 return Py_BuildValue((char *)"");
36838 }
36839 static int _wrap_ControlNameStr_set(PyObject *) {
36840 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36841 return 1;
36842 }
36843
36844
36845 static PyObject *_wrap_ControlNameStr_get(void) {
36846 PyObject *pyobj;
36847
36848 {
36849 #if wxUSE_UNICODE
36850 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36851 #else
36852 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36853 #endif
36854 }
36855 return pyobj;
36856 }
36857
36858
36859 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36860 PyObject *resultobj;
36861 wxWindow *arg1 = (wxWindow *) 0 ;
36862 int arg2 = (int) -1 ;
36863 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36864 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36865 wxSize const &arg4_defvalue = wxDefaultSize ;
36866 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36867 long arg5 = (long) 0 ;
36868 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36869 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36870 wxString const &arg7_defvalue = wxPyControlNameStr ;
36871 wxString *arg7 = (wxString *) &arg7_defvalue ;
36872 wxControl *result;
36873 wxPoint temp3 ;
36874 wxSize temp4 ;
36875 bool temp7 = false ;
36876 PyObject * obj0 = 0 ;
36877 PyObject * obj1 = 0 ;
36878 PyObject * obj2 = 0 ;
36879 PyObject * obj3 = 0 ;
36880 PyObject * obj4 = 0 ;
36881 PyObject * obj5 = 0 ;
36882 PyObject * obj6 = 0 ;
36883 char *kwnames[] = {
36884 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36885 };
36886
36887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36889 if (SWIG_arg_fail(1)) SWIG_fail;
36890 if (obj1) {
36891 {
36892 arg2 = (int)(SWIG_As_int(obj1));
36893 if (SWIG_arg_fail(2)) SWIG_fail;
36894 }
36895 }
36896 if (obj2) {
36897 {
36898 arg3 = &temp3;
36899 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36900 }
36901 }
36902 if (obj3) {
36903 {
36904 arg4 = &temp4;
36905 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36906 }
36907 }
36908 if (obj4) {
36909 {
36910 arg5 = (long)(SWIG_As_long(obj4));
36911 if (SWIG_arg_fail(5)) SWIG_fail;
36912 }
36913 }
36914 if (obj5) {
36915 {
36916 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36917 if (SWIG_arg_fail(6)) SWIG_fail;
36918 if (arg6 == NULL) {
36919 SWIG_null_ref("wxValidator");
36920 }
36921 if (SWIG_arg_fail(6)) SWIG_fail;
36922 }
36923 }
36924 if (obj6) {
36925 {
36926 arg7 = wxString_in_helper(obj6);
36927 if (arg7 == NULL) SWIG_fail;
36928 temp7 = true;
36929 }
36930 }
36931 {
36932 if (!wxPyCheckForApp()) SWIG_fail;
36933 PyThreadState* __tstate = wxPyBeginAllowThreads();
36934 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36935
36936 wxPyEndAllowThreads(__tstate);
36937 if (PyErr_Occurred()) SWIG_fail;
36938 }
36939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36940 {
36941 if (temp7)
36942 delete arg7;
36943 }
36944 return resultobj;
36945 fail:
36946 {
36947 if (temp7)
36948 delete arg7;
36949 }
36950 return NULL;
36951 }
36952
36953
36954 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36955 PyObject *resultobj;
36956 wxControl *result;
36957 char *kwnames[] = {
36958 NULL
36959 };
36960
36961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36962 {
36963 if (!wxPyCheckForApp()) SWIG_fail;
36964 PyThreadState* __tstate = wxPyBeginAllowThreads();
36965 result = (wxControl *)new wxControl();
36966
36967 wxPyEndAllowThreads(__tstate);
36968 if (PyErr_Occurred()) SWIG_fail;
36969 }
36970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36971 return resultobj;
36972 fail:
36973 return NULL;
36974 }
36975
36976
36977 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36978 PyObject *resultobj;
36979 wxControl *arg1 = (wxControl *) 0 ;
36980 wxWindow *arg2 = (wxWindow *) 0 ;
36981 int arg3 = (int) -1 ;
36982 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36983 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36984 wxSize const &arg5_defvalue = wxDefaultSize ;
36985 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36986 long arg6 = (long) 0 ;
36987 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36988 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36989 wxString const &arg8_defvalue = wxPyControlNameStr ;
36990 wxString *arg8 = (wxString *) &arg8_defvalue ;
36991 bool result;
36992 wxPoint temp4 ;
36993 wxSize temp5 ;
36994 bool temp8 = false ;
36995 PyObject * obj0 = 0 ;
36996 PyObject * obj1 = 0 ;
36997 PyObject * obj2 = 0 ;
36998 PyObject * obj3 = 0 ;
36999 PyObject * obj4 = 0 ;
37000 PyObject * obj5 = 0 ;
37001 PyObject * obj6 = 0 ;
37002 PyObject * obj7 = 0 ;
37003 char *kwnames[] = {
37004 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37005 };
37006
37007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37009 if (SWIG_arg_fail(1)) SWIG_fail;
37010 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37011 if (SWIG_arg_fail(2)) SWIG_fail;
37012 if (obj2) {
37013 {
37014 arg3 = (int)(SWIG_As_int(obj2));
37015 if (SWIG_arg_fail(3)) SWIG_fail;
37016 }
37017 }
37018 if (obj3) {
37019 {
37020 arg4 = &temp4;
37021 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37022 }
37023 }
37024 if (obj4) {
37025 {
37026 arg5 = &temp5;
37027 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37028 }
37029 }
37030 if (obj5) {
37031 {
37032 arg6 = (long)(SWIG_As_long(obj5));
37033 if (SWIG_arg_fail(6)) SWIG_fail;
37034 }
37035 }
37036 if (obj6) {
37037 {
37038 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37039 if (SWIG_arg_fail(7)) SWIG_fail;
37040 if (arg7 == NULL) {
37041 SWIG_null_ref("wxValidator");
37042 }
37043 if (SWIG_arg_fail(7)) SWIG_fail;
37044 }
37045 }
37046 if (obj7) {
37047 {
37048 arg8 = wxString_in_helper(obj7);
37049 if (arg8 == NULL) SWIG_fail;
37050 temp8 = true;
37051 }
37052 }
37053 {
37054 PyThreadState* __tstate = wxPyBeginAllowThreads();
37055 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37056
37057 wxPyEndAllowThreads(__tstate);
37058 if (PyErr_Occurred()) SWIG_fail;
37059 }
37060 {
37061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37062 }
37063 {
37064 if (temp8)
37065 delete arg8;
37066 }
37067 return resultobj;
37068 fail:
37069 {
37070 if (temp8)
37071 delete arg8;
37072 }
37073 return NULL;
37074 }
37075
37076
37077 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37078 PyObject *resultobj;
37079 wxControl *arg1 = (wxControl *) 0 ;
37080 wxCommandEvent *arg2 = 0 ;
37081 PyObject * obj0 = 0 ;
37082 PyObject * obj1 = 0 ;
37083 char *kwnames[] = {
37084 (char *) "self",(char *) "event", NULL
37085 };
37086
37087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37089 if (SWIG_arg_fail(1)) SWIG_fail;
37090 {
37091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37092 if (SWIG_arg_fail(2)) SWIG_fail;
37093 if (arg2 == NULL) {
37094 SWIG_null_ref("wxCommandEvent");
37095 }
37096 if (SWIG_arg_fail(2)) SWIG_fail;
37097 }
37098 {
37099 PyThreadState* __tstate = wxPyBeginAllowThreads();
37100 (arg1)->Command(*arg2);
37101
37102 wxPyEndAllowThreads(__tstate);
37103 if (PyErr_Occurred()) SWIG_fail;
37104 }
37105 Py_INCREF(Py_None); resultobj = Py_None;
37106 return resultobj;
37107 fail:
37108 return NULL;
37109 }
37110
37111
37112 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37113 PyObject *resultobj;
37114 wxControl *arg1 = (wxControl *) 0 ;
37115 wxString result;
37116 PyObject * obj0 = 0 ;
37117 char *kwnames[] = {
37118 (char *) "self", NULL
37119 };
37120
37121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37123 if (SWIG_arg_fail(1)) SWIG_fail;
37124 {
37125 PyThreadState* __tstate = wxPyBeginAllowThreads();
37126 result = (arg1)->GetLabel();
37127
37128 wxPyEndAllowThreads(__tstate);
37129 if (PyErr_Occurred()) SWIG_fail;
37130 }
37131 {
37132 #if wxUSE_UNICODE
37133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37134 #else
37135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37136 #endif
37137 }
37138 return resultobj;
37139 fail:
37140 return NULL;
37141 }
37142
37143
37144 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37145 PyObject *resultobj;
37146 wxControl *arg1 = (wxControl *) 0 ;
37147 wxString *arg2 = 0 ;
37148 bool temp2 = false ;
37149 PyObject * obj0 = 0 ;
37150 PyObject * obj1 = 0 ;
37151 char *kwnames[] = {
37152 (char *) "self",(char *) "label", NULL
37153 };
37154
37155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37157 if (SWIG_arg_fail(1)) SWIG_fail;
37158 {
37159 arg2 = wxString_in_helper(obj1);
37160 if (arg2 == NULL) SWIG_fail;
37161 temp2 = true;
37162 }
37163 {
37164 PyThreadState* __tstate = wxPyBeginAllowThreads();
37165 (arg1)->SetLabel((wxString const &)*arg2);
37166
37167 wxPyEndAllowThreads(__tstate);
37168 if (PyErr_Occurred()) SWIG_fail;
37169 }
37170 Py_INCREF(Py_None); resultobj = Py_None;
37171 {
37172 if (temp2)
37173 delete arg2;
37174 }
37175 return resultobj;
37176 fail:
37177 {
37178 if (temp2)
37179 delete arg2;
37180 }
37181 return NULL;
37182 }
37183
37184
37185 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37186 PyObject *resultobj;
37187 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37188 wxVisualAttributes result;
37189 PyObject * obj0 = 0 ;
37190 char *kwnames[] = {
37191 (char *) "variant", NULL
37192 };
37193
37194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37195 if (obj0) {
37196 {
37197 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37198 if (SWIG_arg_fail(1)) SWIG_fail;
37199 }
37200 }
37201 {
37202 if (!wxPyCheckForApp()) SWIG_fail;
37203 PyThreadState* __tstate = wxPyBeginAllowThreads();
37204 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37205
37206 wxPyEndAllowThreads(__tstate);
37207 if (PyErr_Occurred()) SWIG_fail;
37208 }
37209 {
37210 wxVisualAttributes * resultptr;
37211 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37213 }
37214 return resultobj;
37215 fail:
37216 return NULL;
37217 }
37218
37219
37220 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37221 PyObject *obj;
37222 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37223 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37224 Py_INCREF(obj);
37225 return Py_BuildValue((char *)"");
37226 }
37227 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37228 PyObject *resultobj;
37229 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37230 wxString *arg2 = 0 ;
37231 PyObject *arg3 = (PyObject *) NULL ;
37232 int result;
37233 bool temp2 = false ;
37234 PyObject * obj0 = 0 ;
37235 PyObject * obj1 = 0 ;
37236 PyObject * obj2 = 0 ;
37237 char *kwnames[] = {
37238 (char *) "self",(char *) "item",(char *) "clientData", NULL
37239 };
37240
37241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37243 if (SWIG_arg_fail(1)) SWIG_fail;
37244 {
37245 arg2 = wxString_in_helper(obj1);
37246 if (arg2 == NULL) SWIG_fail;
37247 temp2 = true;
37248 }
37249 if (obj2) {
37250 arg3 = obj2;
37251 }
37252 {
37253 PyThreadState* __tstate = wxPyBeginAllowThreads();
37254 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37255
37256 wxPyEndAllowThreads(__tstate);
37257 if (PyErr_Occurred()) SWIG_fail;
37258 }
37259 {
37260 resultobj = SWIG_From_int((int)(result));
37261 }
37262 {
37263 if (temp2)
37264 delete arg2;
37265 }
37266 return resultobj;
37267 fail:
37268 {
37269 if (temp2)
37270 delete arg2;
37271 }
37272 return NULL;
37273 }
37274
37275
37276 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37277 PyObject *resultobj;
37278 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37279 wxArrayString *arg2 = 0 ;
37280 bool temp2 = false ;
37281 PyObject * obj0 = 0 ;
37282 PyObject * obj1 = 0 ;
37283 char *kwnames[] = {
37284 (char *) "self",(char *) "strings", NULL
37285 };
37286
37287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37289 if (SWIG_arg_fail(1)) SWIG_fail;
37290 {
37291 if (! PySequence_Check(obj1)) {
37292 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37293 SWIG_fail;
37294 }
37295 arg2 = new wxArrayString;
37296 temp2 = true;
37297 int i, len=PySequence_Length(obj1);
37298 for (i=0; i<len; i++) {
37299 PyObject* item = PySequence_GetItem(obj1, i);
37300 #if wxUSE_UNICODE
37301 PyObject* str = PyObject_Unicode(item);
37302 #else
37303 PyObject* str = PyObject_Str(item);
37304 #endif
37305 if (PyErr_Occurred()) SWIG_fail;
37306 arg2->Add(Py2wxString(str));
37307 Py_DECREF(item);
37308 Py_DECREF(str);
37309 }
37310 }
37311 {
37312 PyThreadState* __tstate = wxPyBeginAllowThreads();
37313 (arg1)->Append((wxArrayString const &)*arg2);
37314
37315 wxPyEndAllowThreads(__tstate);
37316 if (PyErr_Occurred()) SWIG_fail;
37317 }
37318 Py_INCREF(Py_None); resultobj = Py_None;
37319 {
37320 if (temp2) delete arg2;
37321 }
37322 return resultobj;
37323 fail:
37324 {
37325 if (temp2) delete arg2;
37326 }
37327 return NULL;
37328 }
37329
37330
37331 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37332 PyObject *resultobj;
37333 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37334 wxString *arg2 = 0 ;
37335 int arg3 ;
37336 PyObject *arg4 = (PyObject *) NULL ;
37337 int result;
37338 bool temp2 = false ;
37339 PyObject * obj0 = 0 ;
37340 PyObject * obj1 = 0 ;
37341 PyObject * obj2 = 0 ;
37342 PyObject * obj3 = 0 ;
37343 char *kwnames[] = {
37344 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37345 };
37346
37347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37349 if (SWIG_arg_fail(1)) SWIG_fail;
37350 {
37351 arg2 = wxString_in_helper(obj1);
37352 if (arg2 == NULL) SWIG_fail;
37353 temp2 = true;
37354 }
37355 {
37356 arg3 = (int)(SWIG_As_int(obj2));
37357 if (SWIG_arg_fail(3)) SWIG_fail;
37358 }
37359 if (obj3) {
37360 arg4 = obj3;
37361 }
37362 {
37363 PyThreadState* __tstate = wxPyBeginAllowThreads();
37364 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37365
37366 wxPyEndAllowThreads(__tstate);
37367 if (PyErr_Occurred()) SWIG_fail;
37368 }
37369 {
37370 resultobj = SWIG_From_int((int)(result));
37371 }
37372 {
37373 if (temp2)
37374 delete arg2;
37375 }
37376 return resultobj;
37377 fail:
37378 {
37379 if (temp2)
37380 delete arg2;
37381 }
37382 return NULL;
37383 }
37384
37385
37386 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37387 PyObject *resultobj;
37388 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37389 PyObject * obj0 = 0 ;
37390 char *kwnames[] = {
37391 (char *) "self", NULL
37392 };
37393
37394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37396 if (SWIG_arg_fail(1)) SWIG_fail;
37397 {
37398 PyThreadState* __tstate = wxPyBeginAllowThreads();
37399 (arg1)->Clear();
37400
37401 wxPyEndAllowThreads(__tstate);
37402 if (PyErr_Occurred()) SWIG_fail;
37403 }
37404 Py_INCREF(Py_None); resultobj = Py_None;
37405 return resultobj;
37406 fail:
37407 return NULL;
37408 }
37409
37410
37411 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37412 PyObject *resultobj;
37413 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37414 int arg2 ;
37415 PyObject * obj0 = 0 ;
37416 PyObject * obj1 = 0 ;
37417 char *kwnames[] = {
37418 (char *) "self",(char *) "n", NULL
37419 };
37420
37421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37423 if (SWIG_arg_fail(1)) SWIG_fail;
37424 {
37425 arg2 = (int)(SWIG_As_int(obj1));
37426 if (SWIG_arg_fail(2)) SWIG_fail;
37427 }
37428 {
37429 PyThreadState* __tstate = wxPyBeginAllowThreads();
37430 (arg1)->Delete(arg2);
37431
37432 wxPyEndAllowThreads(__tstate);
37433 if (PyErr_Occurred()) SWIG_fail;
37434 }
37435 Py_INCREF(Py_None); resultobj = Py_None;
37436 return resultobj;
37437 fail:
37438 return NULL;
37439 }
37440
37441
37442 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37443 PyObject *resultobj;
37444 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37445 int arg2 ;
37446 PyObject *result;
37447 PyObject * obj0 = 0 ;
37448 PyObject * obj1 = 0 ;
37449 char *kwnames[] = {
37450 (char *) "self",(char *) "n", NULL
37451 };
37452
37453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37455 if (SWIG_arg_fail(1)) SWIG_fail;
37456 {
37457 arg2 = (int)(SWIG_As_int(obj1));
37458 if (SWIG_arg_fail(2)) SWIG_fail;
37459 }
37460 {
37461 PyThreadState* __tstate = wxPyBeginAllowThreads();
37462 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37463
37464 wxPyEndAllowThreads(__tstate);
37465 if (PyErr_Occurred()) SWIG_fail;
37466 }
37467 resultobj = result;
37468 return resultobj;
37469 fail:
37470 return NULL;
37471 }
37472
37473
37474 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37475 PyObject *resultobj;
37476 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37477 int arg2 ;
37478 PyObject *arg3 = (PyObject *) 0 ;
37479 PyObject * obj0 = 0 ;
37480 PyObject * obj1 = 0 ;
37481 PyObject * obj2 = 0 ;
37482 char *kwnames[] = {
37483 (char *) "self",(char *) "n",(char *) "clientData", NULL
37484 };
37485
37486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37488 if (SWIG_arg_fail(1)) SWIG_fail;
37489 {
37490 arg2 = (int)(SWIG_As_int(obj1));
37491 if (SWIG_arg_fail(2)) SWIG_fail;
37492 }
37493 arg3 = obj2;
37494 {
37495 PyThreadState* __tstate = wxPyBeginAllowThreads();
37496 wxItemContainer_SetClientData(arg1,arg2,arg3);
37497
37498 wxPyEndAllowThreads(__tstate);
37499 if (PyErr_Occurred()) SWIG_fail;
37500 }
37501 Py_INCREF(Py_None); resultobj = Py_None;
37502 return resultobj;
37503 fail:
37504 return NULL;
37505 }
37506
37507
37508 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37509 PyObject *resultobj;
37510 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37511 int result;
37512 PyObject * obj0 = 0 ;
37513 char *kwnames[] = {
37514 (char *) "self", NULL
37515 };
37516
37517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37519 if (SWIG_arg_fail(1)) SWIG_fail;
37520 {
37521 PyThreadState* __tstate = wxPyBeginAllowThreads();
37522 result = (int)((wxItemContainer const *)arg1)->GetCount();
37523
37524 wxPyEndAllowThreads(__tstate);
37525 if (PyErr_Occurred()) SWIG_fail;
37526 }
37527 {
37528 resultobj = SWIG_From_int((int)(result));
37529 }
37530 return resultobj;
37531 fail:
37532 return NULL;
37533 }
37534
37535
37536 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37537 PyObject *resultobj;
37538 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37539 bool result;
37540 PyObject * obj0 = 0 ;
37541 char *kwnames[] = {
37542 (char *) "self", NULL
37543 };
37544
37545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37547 if (SWIG_arg_fail(1)) SWIG_fail;
37548 {
37549 PyThreadState* __tstate = wxPyBeginAllowThreads();
37550 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37551
37552 wxPyEndAllowThreads(__tstate);
37553 if (PyErr_Occurred()) SWIG_fail;
37554 }
37555 {
37556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37557 }
37558 return resultobj;
37559 fail:
37560 return NULL;
37561 }
37562
37563
37564 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37565 PyObject *resultobj;
37566 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37567 int arg2 ;
37568 wxString result;
37569 PyObject * obj0 = 0 ;
37570 PyObject * obj1 = 0 ;
37571 char *kwnames[] = {
37572 (char *) "self",(char *) "n", NULL
37573 };
37574
37575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37577 if (SWIG_arg_fail(1)) SWIG_fail;
37578 {
37579 arg2 = (int)(SWIG_As_int(obj1));
37580 if (SWIG_arg_fail(2)) SWIG_fail;
37581 }
37582 {
37583 PyThreadState* __tstate = wxPyBeginAllowThreads();
37584 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37585
37586 wxPyEndAllowThreads(__tstate);
37587 if (PyErr_Occurred()) SWIG_fail;
37588 }
37589 {
37590 #if wxUSE_UNICODE
37591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37592 #else
37593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37594 #endif
37595 }
37596 return resultobj;
37597 fail:
37598 return NULL;
37599 }
37600
37601
37602 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37603 PyObject *resultobj;
37604 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37605 wxArrayString result;
37606 PyObject * obj0 = 0 ;
37607 char *kwnames[] = {
37608 (char *) "self", NULL
37609 };
37610
37611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37613 if (SWIG_arg_fail(1)) SWIG_fail;
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 result = ((wxItemContainer const *)arg1)->GetStrings();
37617
37618 wxPyEndAllowThreads(__tstate);
37619 if (PyErr_Occurred()) SWIG_fail;
37620 }
37621 {
37622 resultobj = wxArrayString2PyList_helper(result);
37623 }
37624 return resultobj;
37625 fail:
37626 return NULL;
37627 }
37628
37629
37630 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37631 PyObject *resultobj;
37632 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37633 int arg2 ;
37634 wxString *arg3 = 0 ;
37635 bool temp3 = false ;
37636 PyObject * obj0 = 0 ;
37637 PyObject * obj1 = 0 ;
37638 PyObject * obj2 = 0 ;
37639 char *kwnames[] = {
37640 (char *) "self",(char *) "n",(char *) "s", NULL
37641 };
37642
37643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37645 if (SWIG_arg_fail(1)) SWIG_fail;
37646 {
37647 arg2 = (int)(SWIG_As_int(obj1));
37648 if (SWIG_arg_fail(2)) SWIG_fail;
37649 }
37650 {
37651 arg3 = wxString_in_helper(obj2);
37652 if (arg3 == NULL) SWIG_fail;
37653 temp3 = true;
37654 }
37655 {
37656 PyThreadState* __tstate = wxPyBeginAllowThreads();
37657 (arg1)->SetString(arg2,(wxString const &)*arg3);
37658
37659 wxPyEndAllowThreads(__tstate);
37660 if (PyErr_Occurred()) SWIG_fail;
37661 }
37662 Py_INCREF(Py_None); resultobj = Py_None;
37663 {
37664 if (temp3)
37665 delete arg3;
37666 }
37667 return resultobj;
37668 fail:
37669 {
37670 if (temp3)
37671 delete arg3;
37672 }
37673 return NULL;
37674 }
37675
37676
37677 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37678 PyObject *resultobj;
37679 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37680 wxString *arg2 = 0 ;
37681 int result;
37682 bool temp2 = false ;
37683 PyObject * obj0 = 0 ;
37684 PyObject * obj1 = 0 ;
37685 char *kwnames[] = {
37686 (char *) "self",(char *) "s", NULL
37687 };
37688
37689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37691 if (SWIG_arg_fail(1)) SWIG_fail;
37692 {
37693 arg2 = wxString_in_helper(obj1);
37694 if (arg2 == NULL) SWIG_fail;
37695 temp2 = true;
37696 }
37697 {
37698 PyThreadState* __tstate = wxPyBeginAllowThreads();
37699 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37700
37701 wxPyEndAllowThreads(__tstate);
37702 if (PyErr_Occurred()) SWIG_fail;
37703 }
37704 {
37705 resultobj = SWIG_From_int((int)(result));
37706 }
37707 {
37708 if (temp2)
37709 delete arg2;
37710 }
37711 return resultobj;
37712 fail:
37713 {
37714 if (temp2)
37715 delete arg2;
37716 }
37717 return NULL;
37718 }
37719
37720
37721 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37722 PyObject *resultobj;
37723 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37724 int arg2 ;
37725 PyObject * obj0 = 0 ;
37726 PyObject * obj1 = 0 ;
37727 char *kwnames[] = {
37728 (char *) "self",(char *) "n", NULL
37729 };
37730
37731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37733 if (SWIG_arg_fail(1)) SWIG_fail;
37734 {
37735 arg2 = (int)(SWIG_As_int(obj1));
37736 if (SWIG_arg_fail(2)) SWIG_fail;
37737 }
37738 {
37739 PyThreadState* __tstate = wxPyBeginAllowThreads();
37740 (arg1)->SetSelection(arg2);
37741
37742 wxPyEndAllowThreads(__tstate);
37743 if (PyErr_Occurred()) SWIG_fail;
37744 }
37745 Py_INCREF(Py_None); resultobj = Py_None;
37746 return resultobj;
37747 fail:
37748 return NULL;
37749 }
37750
37751
37752 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37753 PyObject *resultobj;
37754 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37755 int result;
37756 PyObject * obj0 = 0 ;
37757 char *kwnames[] = {
37758 (char *) "self", NULL
37759 };
37760
37761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37763 if (SWIG_arg_fail(1)) SWIG_fail;
37764 {
37765 PyThreadState* __tstate = wxPyBeginAllowThreads();
37766 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37767
37768 wxPyEndAllowThreads(__tstate);
37769 if (PyErr_Occurred()) SWIG_fail;
37770 }
37771 {
37772 resultobj = SWIG_From_int((int)(result));
37773 }
37774 return resultobj;
37775 fail:
37776 return NULL;
37777 }
37778
37779
37780 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37781 PyObject *resultobj;
37782 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37783 wxString *arg2 = 0 ;
37784 bool result;
37785 bool temp2 = false ;
37786 PyObject * obj0 = 0 ;
37787 PyObject * obj1 = 0 ;
37788 char *kwnames[] = {
37789 (char *) "self",(char *) "s", NULL
37790 };
37791
37792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37794 if (SWIG_arg_fail(1)) SWIG_fail;
37795 {
37796 arg2 = wxString_in_helper(obj1);
37797 if (arg2 == NULL) SWIG_fail;
37798 temp2 = true;
37799 }
37800 {
37801 PyThreadState* __tstate = wxPyBeginAllowThreads();
37802 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37803
37804 wxPyEndAllowThreads(__tstate);
37805 if (PyErr_Occurred()) SWIG_fail;
37806 }
37807 {
37808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37809 }
37810 {
37811 if (temp2)
37812 delete arg2;
37813 }
37814 return resultobj;
37815 fail:
37816 {
37817 if (temp2)
37818 delete arg2;
37819 }
37820 return NULL;
37821 }
37822
37823
37824 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37825 PyObject *resultobj;
37826 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37827 wxString result;
37828 PyObject * obj0 = 0 ;
37829 char *kwnames[] = {
37830 (char *) "self", NULL
37831 };
37832
37833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37835 if (SWIG_arg_fail(1)) SWIG_fail;
37836 {
37837 PyThreadState* __tstate = wxPyBeginAllowThreads();
37838 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37839
37840 wxPyEndAllowThreads(__tstate);
37841 if (PyErr_Occurred()) SWIG_fail;
37842 }
37843 {
37844 #if wxUSE_UNICODE
37845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37846 #else
37847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37848 #endif
37849 }
37850 return resultobj;
37851 fail:
37852 return NULL;
37853 }
37854
37855
37856 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37857 PyObject *resultobj;
37858 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37859 int arg2 ;
37860 PyObject * obj0 = 0 ;
37861 PyObject * obj1 = 0 ;
37862 char *kwnames[] = {
37863 (char *) "self",(char *) "n", NULL
37864 };
37865
37866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37868 if (SWIG_arg_fail(1)) SWIG_fail;
37869 {
37870 arg2 = (int)(SWIG_As_int(obj1));
37871 if (SWIG_arg_fail(2)) SWIG_fail;
37872 }
37873 {
37874 PyThreadState* __tstate = wxPyBeginAllowThreads();
37875 (arg1)->Select(arg2);
37876
37877 wxPyEndAllowThreads(__tstate);
37878 if (PyErr_Occurred()) SWIG_fail;
37879 }
37880 Py_INCREF(Py_None); resultobj = Py_None;
37881 return resultobj;
37882 fail:
37883 return NULL;
37884 }
37885
37886
37887 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37888 PyObject *obj;
37889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37890 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37891 Py_INCREF(obj);
37892 return Py_BuildValue((char *)"");
37893 }
37894 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37895 PyObject *obj;
37896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37897 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37898 Py_INCREF(obj);
37899 return Py_BuildValue((char *)"");
37900 }
37901 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37902 PyObject *resultobj;
37903 wxSizerItem *result;
37904 char *kwnames[] = {
37905 NULL
37906 };
37907
37908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37909 {
37910 PyThreadState* __tstate = wxPyBeginAllowThreads();
37911 result = (wxSizerItem *)new wxSizerItem();
37912
37913 wxPyEndAllowThreads(__tstate);
37914 if (PyErr_Occurred()) SWIG_fail;
37915 }
37916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37917 return resultobj;
37918 fail:
37919 return NULL;
37920 }
37921
37922
37923 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37924 PyObject *resultobj;
37925 wxWindow *arg1 = (wxWindow *) 0 ;
37926 int arg2 ;
37927 int arg3 ;
37928 int arg4 ;
37929 PyObject *arg5 = (PyObject *) NULL ;
37930 wxSizerItem *result;
37931 PyObject * obj0 = 0 ;
37932 PyObject * obj1 = 0 ;
37933 PyObject * obj2 = 0 ;
37934 PyObject * obj3 = 0 ;
37935 PyObject * obj4 = 0 ;
37936 char *kwnames[] = {
37937 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37938 };
37939
37940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37942 if (SWIG_arg_fail(1)) SWIG_fail;
37943 {
37944 arg2 = (int)(SWIG_As_int(obj1));
37945 if (SWIG_arg_fail(2)) SWIG_fail;
37946 }
37947 {
37948 arg3 = (int)(SWIG_As_int(obj2));
37949 if (SWIG_arg_fail(3)) SWIG_fail;
37950 }
37951 {
37952 arg4 = (int)(SWIG_As_int(obj3));
37953 if (SWIG_arg_fail(4)) SWIG_fail;
37954 }
37955 if (obj4) {
37956 arg5 = obj4;
37957 }
37958 {
37959 PyThreadState* __tstate = wxPyBeginAllowThreads();
37960 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37961
37962 wxPyEndAllowThreads(__tstate);
37963 if (PyErr_Occurred()) SWIG_fail;
37964 }
37965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37966 return resultobj;
37967 fail:
37968 return NULL;
37969 }
37970
37971
37972 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37973 PyObject *resultobj;
37974 int arg1 ;
37975 int arg2 ;
37976 int arg3 ;
37977 int arg4 ;
37978 int arg5 ;
37979 PyObject *arg6 = (PyObject *) NULL ;
37980 wxSizerItem *result;
37981 PyObject * obj0 = 0 ;
37982 PyObject * obj1 = 0 ;
37983 PyObject * obj2 = 0 ;
37984 PyObject * obj3 = 0 ;
37985 PyObject * obj4 = 0 ;
37986 PyObject * obj5 = 0 ;
37987 char *kwnames[] = {
37988 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37989 };
37990
37991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37992 {
37993 arg1 = (int)(SWIG_As_int(obj0));
37994 if (SWIG_arg_fail(1)) SWIG_fail;
37995 }
37996 {
37997 arg2 = (int)(SWIG_As_int(obj1));
37998 if (SWIG_arg_fail(2)) SWIG_fail;
37999 }
38000 {
38001 arg3 = (int)(SWIG_As_int(obj2));
38002 if (SWIG_arg_fail(3)) SWIG_fail;
38003 }
38004 {
38005 arg4 = (int)(SWIG_As_int(obj3));
38006 if (SWIG_arg_fail(4)) SWIG_fail;
38007 }
38008 {
38009 arg5 = (int)(SWIG_As_int(obj4));
38010 if (SWIG_arg_fail(5)) SWIG_fail;
38011 }
38012 if (obj5) {
38013 arg6 = obj5;
38014 }
38015 {
38016 PyThreadState* __tstate = wxPyBeginAllowThreads();
38017 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38018
38019 wxPyEndAllowThreads(__tstate);
38020 if (PyErr_Occurred()) SWIG_fail;
38021 }
38022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38023 return resultobj;
38024 fail:
38025 return NULL;
38026 }
38027
38028
38029 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38030 PyObject *resultobj;
38031 wxSizer *arg1 = (wxSizer *) 0 ;
38032 int arg2 ;
38033 int arg3 ;
38034 int arg4 ;
38035 PyObject *arg5 = (PyObject *) NULL ;
38036 wxSizerItem *result;
38037 PyObject * obj0 = 0 ;
38038 PyObject * obj1 = 0 ;
38039 PyObject * obj2 = 0 ;
38040 PyObject * obj3 = 0 ;
38041 PyObject * obj4 = 0 ;
38042 char *kwnames[] = {
38043 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38044 };
38045
38046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38048 if (SWIG_arg_fail(1)) SWIG_fail;
38049 {
38050 arg2 = (int)(SWIG_As_int(obj1));
38051 if (SWIG_arg_fail(2)) SWIG_fail;
38052 }
38053 {
38054 arg3 = (int)(SWIG_As_int(obj2));
38055 if (SWIG_arg_fail(3)) SWIG_fail;
38056 }
38057 {
38058 arg4 = (int)(SWIG_As_int(obj3));
38059 if (SWIG_arg_fail(4)) SWIG_fail;
38060 }
38061 if (obj4) {
38062 arg5 = obj4;
38063 }
38064 {
38065 PyThreadState* __tstate = wxPyBeginAllowThreads();
38066 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38067
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38072 return resultobj;
38073 fail:
38074 return NULL;
38075 }
38076
38077
38078 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38079 PyObject *resultobj;
38080 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38081 PyObject * obj0 = 0 ;
38082 char *kwnames[] = {
38083 (char *) "self", NULL
38084 };
38085
38086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38088 if (SWIG_arg_fail(1)) SWIG_fail;
38089 {
38090 PyThreadState* __tstate = wxPyBeginAllowThreads();
38091 (arg1)->DeleteWindows();
38092
38093 wxPyEndAllowThreads(__tstate);
38094 if (PyErr_Occurred()) SWIG_fail;
38095 }
38096 Py_INCREF(Py_None); resultobj = Py_None;
38097 return resultobj;
38098 fail:
38099 return NULL;
38100 }
38101
38102
38103 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38104 PyObject *resultobj;
38105 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38106 PyObject * obj0 = 0 ;
38107 char *kwnames[] = {
38108 (char *) "self", NULL
38109 };
38110
38111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38113 if (SWIG_arg_fail(1)) SWIG_fail;
38114 {
38115 PyThreadState* __tstate = wxPyBeginAllowThreads();
38116 (arg1)->DetachSizer();
38117
38118 wxPyEndAllowThreads(__tstate);
38119 if (PyErr_Occurred()) SWIG_fail;
38120 }
38121 Py_INCREF(Py_None); resultobj = Py_None;
38122 return resultobj;
38123 fail:
38124 return NULL;
38125 }
38126
38127
38128 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38129 PyObject *resultobj;
38130 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38131 wxSize result;
38132 PyObject * obj0 = 0 ;
38133 char *kwnames[] = {
38134 (char *) "self", NULL
38135 };
38136
38137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38139 if (SWIG_arg_fail(1)) SWIG_fail;
38140 {
38141 PyThreadState* __tstate = wxPyBeginAllowThreads();
38142 result = (arg1)->GetSize();
38143
38144 wxPyEndAllowThreads(__tstate);
38145 if (PyErr_Occurred()) SWIG_fail;
38146 }
38147 {
38148 wxSize * resultptr;
38149 resultptr = new wxSize((wxSize &)(result));
38150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38151 }
38152 return resultobj;
38153 fail:
38154 return NULL;
38155 }
38156
38157
38158 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38159 PyObject *resultobj;
38160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38161 wxSize result;
38162 PyObject * obj0 = 0 ;
38163 char *kwnames[] = {
38164 (char *) "self", NULL
38165 };
38166
38167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38169 if (SWIG_arg_fail(1)) SWIG_fail;
38170 {
38171 PyThreadState* __tstate = wxPyBeginAllowThreads();
38172 result = (arg1)->CalcMin();
38173
38174 wxPyEndAllowThreads(__tstate);
38175 if (PyErr_Occurred()) SWIG_fail;
38176 }
38177 {
38178 wxSize * resultptr;
38179 resultptr = new wxSize((wxSize &)(result));
38180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38181 }
38182 return resultobj;
38183 fail:
38184 return NULL;
38185 }
38186
38187
38188 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38189 PyObject *resultobj;
38190 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38191 wxPoint arg2 ;
38192 wxSize arg3 ;
38193 PyObject * obj0 = 0 ;
38194 PyObject * obj1 = 0 ;
38195 PyObject * obj2 = 0 ;
38196 char *kwnames[] = {
38197 (char *) "self",(char *) "pos",(char *) "size", NULL
38198 };
38199
38200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38202 if (SWIG_arg_fail(1)) SWIG_fail;
38203 {
38204 wxPoint * argp;
38205 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38206 if (SWIG_arg_fail(2)) SWIG_fail;
38207 if (argp == NULL) {
38208 SWIG_null_ref("wxPoint");
38209 }
38210 if (SWIG_arg_fail(2)) SWIG_fail;
38211 arg2 = *argp;
38212 }
38213 {
38214 wxSize * argp;
38215 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38216 if (SWIG_arg_fail(3)) SWIG_fail;
38217 if (argp == NULL) {
38218 SWIG_null_ref("wxSize");
38219 }
38220 if (SWIG_arg_fail(3)) SWIG_fail;
38221 arg3 = *argp;
38222 }
38223 {
38224 PyThreadState* __tstate = wxPyBeginAllowThreads();
38225 (arg1)->SetDimension(arg2,arg3);
38226
38227 wxPyEndAllowThreads(__tstate);
38228 if (PyErr_Occurred()) SWIG_fail;
38229 }
38230 Py_INCREF(Py_None); resultobj = Py_None;
38231 return resultobj;
38232 fail:
38233 return NULL;
38234 }
38235
38236
38237 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38238 PyObject *resultobj;
38239 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38240 wxSize result;
38241 PyObject * obj0 = 0 ;
38242 char *kwnames[] = {
38243 (char *) "self", NULL
38244 };
38245
38246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38248 if (SWIG_arg_fail(1)) SWIG_fail;
38249 {
38250 PyThreadState* __tstate = wxPyBeginAllowThreads();
38251 result = (arg1)->GetMinSize();
38252
38253 wxPyEndAllowThreads(__tstate);
38254 if (PyErr_Occurred()) SWIG_fail;
38255 }
38256 {
38257 wxSize * resultptr;
38258 resultptr = new wxSize((wxSize &)(result));
38259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38260 }
38261 return resultobj;
38262 fail:
38263 return NULL;
38264 }
38265
38266
38267 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38268 PyObject *resultobj;
38269 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38270 wxSize result;
38271 PyObject * obj0 = 0 ;
38272 char *kwnames[] = {
38273 (char *) "self", NULL
38274 };
38275
38276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38278 if (SWIG_arg_fail(1)) SWIG_fail;
38279 {
38280 PyThreadState* __tstate = wxPyBeginAllowThreads();
38281 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38282
38283 wxPyEndAllowThreads(__tstate);
38284 if (PyErr_Occurred()) SWIG_fail;
38285 }
38286 {
38287 wxSize * resultptr;
38288 resultptr = new wxSize((wxSize &)(result));
38289 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38290 }
38291 return resultobj;
38292 fail:
38293 return NULL;
38294 }
38295
38296
38297 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38298 PyObject *resultobj;
38299 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38300 int arg2 ;
38301 int arg3 ;
38302 PyObject * obj0 = 0 ;
38303 PyObject * obj1 = 0 ;
38304 PyObject * obj2 = 0 ;
38305 char *kwnames[] = {
38306 (char *) "self",(char *) "x",(char *) "y", NULL
38307 };
38308
38309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38311 if (SWIG_arg_fail(1)) SWIG_fail;
38312 {
38313 arg2 = (int)(SWIG_As_int(obj1));
38314 if (SWIG_arg_fail(2)) SWIG_fail;
38315 }
38316 {
38317 arg3 = (int)(SWIG_As_int(obj2));
38318 if (SWIG_arg_fail(3)) SWIG_fail;
38319 }
38320 {
38321 PyThreadState* __tstate = wxPyBeginAllowThreads();
38322 (arg1)->SetInitSize(arg2,arg3);
38323
38324 wxPyEndAllowThreads(__tstate);
38325 if (PyErr_Occurred()) SWIG_fail;
38326 }
38327 Py_INCREF(Py_None); resultobj = Py_None;
38328 return resultobj;
38329 fail:
38330 return NULL;
38331 }
38332
38333
38334 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38335 PyObject *resultobj;
38336 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38337 int arg2 ;
38338 int arg3 ;
38339 PyObject * obj0 = 0 ;
38340 PyObject * obj1 = 0 ;
38341 PyObject * obj2 = 0 ;
38342 char *kwnames[] = {
38343 (char *) "self",(char *) "width",(char *) "height", NULL
38344 };
38345
38346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38348 if (SWIG_arg_fail(1)) SWIG_fail;
38349 {
38350 arg2 = (int)(SWIG_As_int(obj1));
38351 if (SWIG_arg_fail(2)) SWIG_fail;
38352 }
38353 {
38354 arg3 = (int)(SWIG_As_int(obj2));
38355 if (SWIG_arg_fail(3)) SWIG_fail;
38356 }
38357 {
38358 PyThreadState* __tstate = wxPyBeginAllowThreads();
38359 (arg1)->SetRatio(arg2,arg3);
38360
38361 wxPyEndAllowThreads(__tstate);
38362 if (PyErr_Occurred()) SWIG_fail;
38363 }
38364 Py_INCREF(Py_None); resultobj = Py_None;
38365 return resultobj;
38366 fail:
38367 return NULL;
38368 }
38369
38370
38371 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38372 PyObject *resultobj;
38373 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38374 wxSize arg2 ;
38375 PyObject * obj0 = 0 ;
38376 PyObject * obj1 = 0 ;
38377 char *kwnames[] = {
38378 (char *) "self",(char *) "size", NULL
38379 };
38380
38381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38383 if (SWIG_arg_fail(1)) SWIG_fail;
38384 {
38385 wxSize * argp;
38386 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38387 if (SWIG_arg_fail(2)) SWIG_fail;
38388 if (argp == NULL) {
38389 SWIG_null_ref("wxSize");
38390 }
38391 if (SWIG_arg_fail(2)) SWIG_fail;
38392 arg2 = *argp;
38393 }
38394 {
38395 PyThreadState* __tstate = wxPyBeginAllowThreads();
38396 (arg1)->SetRatio(arg2);
38397
38398 wxPyEndAllowThreads(__tstate);
38399 if (PyErr_Occurred()) SWIG_fail;
38400 }
38401 Py_INCREF(Py_None); resultobj = Py_None;
38402 return resultobj;
38403 fail:
38404 return NULL;
38405 }
38406
38407
38408 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38409 PyObject *resultobj;
38410 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38411 float arg2 ;
38412 PyObject * obj0 = 0 ;
38413 PyObject * obj1 = 0 ;
38414 char *kwnames[] = {
38415 (char *) "self",(char *) "ratio", NULL
38416 };
38417
38418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38420 if (SWIG_arg_fail(1)) SWIG_fail;
38421 {
38422 arg2 = (float)(SWIG_As_float(obj1));
38423 if (SWIG_arg_fail(2)) SWIG_fail;
38424 }
38425 {
38426 PyThreadState* __tstate = wxPyBeginAllowThreads();
38427 (arg1)->SetRatio(arg2);
38428
38429 wxPyEndAllowThreads(__tstate);
38430 if (PyErr_Occurred()) SWIG_fail;
38431 }
38432 Py_INCREF(Py_None); resultobj = Py_None;
38433 return resultobj;
38434 fail:
38435 return NULL;
38436 }
38437
38438
38439 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38440 PyObject *resultobj;
38441 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38442 float result;
38443 PyObject * obj0 = 0 ;
38444 char *kwnames[] = {
38445 (char *) "self", NULL
38446 };
38447
38448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38450 if (SWIG_arg_fail(1)) SWIG_fail;
38451 {
38452 PyThreadState* __tstate = wxPyBeginAllowThreads();
38453 result = (float)(arg1)->GetRatio();
38454
38455 wxPyEndAllowThreads(__tstate);
38456 if (PyErr_Occurred()) SWIG_fail;
38457 }
38458 {
38459 resultobj = SWIG_From_float((float)(result));
38460 }
38461 return resultobj;
38462 fail:
38463 return NULL;
38464 }
38465
38466
38467 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38468 PyObject *resultobj;
38469 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38470 wxRect result;
38471 PyObject * obj0 = 0 ;
38472 char *kwnames[] = {
38473 (char *) "self", NULL
38474 };
38475
38476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38478 if (SWIG_arg_fail(1)) SWIG_fail;
38479 {
38480 PyThreadState* __tstate = wxPyBeginAllowThreads();
38481 result = (arg1)->GetRect();
38482
38483 wxPyEndAllowThreads(__tstate);
38484 if (PyErr_Occurred()) SWIG_fail;
38485 }
38486 {
38487 wxRect * resultptr;
38488 resultptr = new wxRect((wxRect &)(result));
38489 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38490 }
38491 return resultobj;
38492 fail:
38493 return NULL;
38494 }
38495
38496
38497 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38498 PyObject *resultobj;
38499 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38500 bool result;
38501 PyObject * obj0 = 0 ;
38502 char *kwnames[] = {
38503 (char *) "self", NULL
38504 };
38505
38506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38508 if (SWIG_arg_fail(1)) SWIG_fail;
38509 {
38510 PyThreadState* __tstate = wxPyBeginAllowThreads();
38511 result = (bool)(arg1)->IsWindow();
38512
38513 wxPyEndAllowThreads(__tstate);
38514 if (PyErr_Occurred()) SWIG_fail;
38515 }
38516 {
38517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38518 }
38519 return resultobj;
38520 fail:
38521 return NULL;
38522 }
38523
38524
38525 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38526 PyObject *resultobj;
38527 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38528 bool result;
38529 PyObject * obj0 = 0 ;
38530 char *kwnames[] = {
38531 (char *) "self", NULL
38532 };
38533
38534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38536 if (SWIG_arg_fail(1)) SWIG_fail;
38537 {
38538 PyThreadState* __tstate = wxPyBeginAllowThreads();
38539 result = (bool)(arg1)->IsSizer();
38540
38541 wxPyEndAllowThreads(__tstate);
38542 if (PyErr_Occurred()) SWIG_fail;
38543 }
38544 {
38545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38546 }
38547 return resultobj;
38548 fail:
38549 return NULL;
38550 }
38551
38552
38553 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38554 PyObject *resultobj;
38555 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38556 bool result;
38557 PyObject * obj0 = 0 ;
38558 char *kwnames[] = {
38559 (char *) "self", NULL
38560 };
38561
38562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38564 if (SWIG_arg_fail(1)) SWIG_fail;
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 result = (bool)(arg1)->IsSpacer();
38568
38569 wxPyEndAllowThreads(__tstate);
38570 if (PyErr_Occurred()) SWIG_fail;
38571 }
38572 {
38573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38574 }
38575 return resultobj;
38576 fail:
38577 return NULL;
38578 }
38579
38580
38581 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38582 PyObject *resultobj;
38583 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38584 int arg2 ;
38585 PyObject * obj0 = 0 ;
38586 PyObject * obj1 = 0 ;
38587 char *kwnames[] = {
38588 (char *) "self",(char *) "proportion", NULL
38589 };
38590
38591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38593 if (SWIG_arg_fail(1)) SWIG_fail;
38594 {
38595 arg2 = (int)(SWIG_As_int(obj1));
38596 if (SWIG_arg_fail(2)) SWIG_fail;
38597 }
38598 {
38599 PyThreadState* __tstate = wxPyBeginAllowThreads();
38600 (arg1)->SetProportion(arg2);
38601
38602 wxPyEndAllowThreads(__tstate);
38603 if (PyErr_Occurred()) SWIG_fail;
38604 }
38605 Py_INCREF(Py_None); resultobj = Py_None;
38606 return resultobj;
38607 fail:
38608 return NULL;
38609 }
38610
38611
38612 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38613 PyObject *resultobj;
38614 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38615 int result;
38616 PyObject * obj0 = 0 ;
38617 char *kwnames[] = {
38618 (char *) "self", NULL
38619 };
38620
38621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38623 if (SWIG_arg_fail(1)) SWIG_fail;
38624 {
38625 PyThreadState* __tstate = wxPyBeginAllowThreads();
38626 result = (int)(arg1)->GetProportion();
38627
38628 wxPyEndAllowThreads(__tstate);
38629 if (PyErr_Occurred()) SWIG_fail;
38630 }
38631 {
38632 resultobj = SWIG_From_int((int)(result));
38633 }
38634 return resultobj;
38635 fail:
38636 return NULL;
38637 }
38638
38639
38640 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38641 PyObject *resultobj;
38642 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38643 int arg2 ;
38644 PyObject * obj0 = 0 ;
38645 PyObject * obj1 = 0 ;
38646 char *kwnames[] = {
38647 (char *) "self",(char *) "flag", NULL
38648 };
38649
38650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38652 if (SWIG_arg_fail(1)) SWIG_fail;
38653 {
38654 arg2 = (int)(SWIG_As_int(obj1));
38655 if (SWIG_arg_fail(2)) SWIG_fail;
38656 }
38657 {
38658 PyThreadState* __tstate = wxPyBeginAllowThreads();
38659 (arg1)->SetFlag(arg2);
38660
38661 wxPyEndAllowThreads(__tstate);
38662 if (PyErr_Occurred()) SWIG_fail;
38663 }
38664 Py_INCREF(Py_None); resultobj = Py_None;
38665 return resultobj;
38666 fail:
38667 return NULL;
38668 }
38669
38670
38671 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38672 PyObject *resultobj;
38673 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38674 int result;
38675 PyObject * obj0 = 0 ;
38676 char *kwnames[] = {
38677 (char *) "self", NULL
38678 };
38679
38680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38682 if (SWIG_arg_fail(1)) SWIG_fail;
38683 {
38684 PyThreadState* __tstate = wxPyBeginAllowThreads();
38685 result = (int)(arg1)->GetFlag();
38686
38687 wxPyEndAllowThreads(__tstate);
38688 if (PyErr_Occurred()) SWIG_fail;
38689 }
38690 {
38691 resultobj = SWIG_From_int((int)(result));
38692 }
38693 return resultobj;
38694 fail:
38695 return NULL;
38696 }
38697
38698
38699 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38700 PyObject *resultobj;
38701 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38702 int arg2 ;
38703 PyObject * obj0 = 0 ;
38704 PyObject * obj1 = 0 ;
38705 char *kwnames[] = {
38706 (char *) "self",(char *) "border", NULL
38707 };
38708
38709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38711 if (SWIG_arg_fail(1)) SWIG_fail;
38712 {
38713 arg2 = (int)(SWIG_As_int(obj1));
38714 if (SWIG_arg_fail(2)) SWIG_fail;
38715 }
38716 {
38717 PyThreadState* __tstate = wxPyBeginAllowThreads();
38718 (arg1)->SetBorder(arg2);
38719
38720 wxPyEndAllowThreads(__tstate);
38721 if (PyErr_Occurred()) SWIG_fail;
38722 }
38723 Py_INCREF(Py_None); resultobj = Py_None;
38724 return resultobj;
38725 fail:
38726 return NULL;
38727 }
38728
38729
38730 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38731 PyObject *resultobj;
38732 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38733 int result;
38734 PyObject * obj0 = 0 ;
38735 char *kwnames[] = {
38736 (char *) "self", NULL
38737 };
38738
38739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38741 if (SWIG_arg_fail(1)) SWIG_fail;
38742 {
38743 PyThreadState* __tstate = wxPyBeginAllowThreads();
38744 result = (int)(arg1)->GetBorder();
38745
38746 wxPyEndAllowThreads(__tstate);
38747 if (PyErr_Occurred()) SWIG_fail;
38748 }
38749 {
38750 resultobj = SWIG_From_int((int)(result));
38751 }
38752 return resultobj;
38753 fail:
38754 return NULL;
38755 }
38756
38757
38758 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38759 PyObject *resultobj;
38760 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38761 wxWindow *result;
38762 PyObject * obj0 = 0 ;
38763 char *kwnames[] = {
38764 (char *) "self", NULL
38765 };
38766
38767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38769 if (SWIG_arg_fail(1)) SWIG_fail;
38770 {
38771 PyThreadState* __tstate = wxPyBeginAllowThreads();
38772 result = (wxWindow *)(arg1)->GetWindow();
38773
38774 wxPyEndAllowThreads(__tstate);
38775 if (PyErr_Occurred()) SWIG_fail;
38776 }
38777 {
38778 resultobj = wxPyMake_wxObject(result, 0);
38779 }
38780 return resultobj;
38781 fail:
38782 return NULL;
38783 }
38784
38785
38786 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38787 PyObject *resultobj;
38788 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38789 wxWindow *arg2 = (wxWindow *) 0 ;
38790 PyObject * obj0 = 0 ;
38791 PyObject * obj1 = 0 ;
38792 char *kwnames[] = {
38793 (char *) "self",(char *) "window", NULL
38794 };
38795
38796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38798 if (SWIG_arg_fail(1)) SWIG_fail;
38799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38800 if (SWIG_arg_fail(2)) SWIG_fail;
38801 {
38802 PyThreadState* __tstate = wxPyBeginAllowThreads();
38803 (arg1)->SetWindow(arg2);
38804
38805 wxPyEndAllowThreads(__tstate);
38806 if (PyErr_Occurred()) SWIG_fail;
38807 }
38808 Py_INCREF(Py_None); resultobj = Py_None;
38809 return resultobj;
38810 fail:
38811 return NULL;
38812 }
38813
38814
38815 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38816 PyObject *resultobj;
38817 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38818 wxSizer *result;
38819 PyObject * obj0 = 0 ;
38820 char *kwnames[] = {
38821 (char *) "self", NULL
38822 };
38823
38824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38826 if (SWIG_arg_fail(1)) SWIG_fail;
38827 {
38828 PyThreadState* __tstate = wxPyBeginAllowThreads();
38829 result = (wxSizer *)(arg1)->GetSizer();
38830
38831 wxPyEndAllowThreads(__tstate);
38832 if (PyErr_Occurred()) SWIG_fail;
38833 }
38834 {
38835 resultobj = wxPyMake_wxSizer(result, 0);
38836 }
38837 return resultobj;
38838 fail:
38839 return NULL;
38840 }
38841
38842
38843 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38844 PyObject *resultobj;
38845 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38846 wxSizer *arg2 = (wxSizer *) 0 ;
38847 PyObject * obj0 = 0 ;
38848 PyObject * obj1 = 0 ;
38849 char *kwnames[] = {
38850 (char *) "self",(char *) "sizer", NULL
38851 };
38852
38853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38855 if (SWIG_arg_fail(1)) SWIG_fail;
38856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38857 if (SWIG_arg_fail(2)) SWIG_fail;
38858 {
38859 PyThreadState* __tstate = wxPyBeginAllowThreads();
38860 (arg1)->SetSizer(arg2);
38861
38862 wxPyEndAllowThreads(__tstate);
38863 if (PyErr_Occurred()) SWIG_fail;
38864 }
38865 Py_INCREF(Py_None); resultobj = Py_None;
38866 return resultobj;
38867 fail:
38868 return NULL;
38869 }
38870
38871
38872 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38873 PyObject *resultobj;
38874 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38875 wxSize *result;
38876 PyObject * obj0 = 0 ;
38877 char *kwnames[] = {
38878 (char *) "self", NULL
38879 };
38880
38881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38883 if (SWIG_arg_fail(1)) SWIG_fail;
38884 {
38885 PyThreadState* __tstate = wxPyBeginAllowThreads();
38886 {
38887 wxSize const &_result_ref = (arg1)->GetSpacer();
38888 result = (wxSize *) &_result_ref;
38889 }
38890
38891 wxPyEndAllowThreads(__tstate);
38892 if (PyErr_Occurred()) SWIG_fail;
38893 }
38894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38895 return resultobj;
38896 fail:
38897 return NULL;
38898 }
38899
38900
38901 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38902 PyObject *resultobj;
38903 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38904 wxSize *arg2 = 0 ;
38905 wxSize temp2 ;
38906 PyObject * obj0 = 0 ;
38907 PyObject * obj1 = 0 ;
38908 char *kwnames[] = {
38909 (char *) "self",(char *) "size", NULL
38910 };
38911
38912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38914 if (SWIG_arg_fail(1)) SWIG_fail;
38915 {
38916 arg2 = &temp2;
38917 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38918 }
38919 {
38920 PyThreadState* __tstate = wxPyBeginAllowThreads();
38921 (arg1)->SetSpacer((wxSize const &)*arg2);
38922
38923 wxPyEndAllowThreads(__tstate);
38924 if (PyErr_Occurred()) SWIG_fail;
38925 }
38926 Py_INCREF(Py_None); resultobj = Py_None;
38927 return resultobj;
38928 fail:
38929 return NULL;
38930 }
38931
38932
38933 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38934 PyObject *resultobj;
38935 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38936 bool arg2 ;
38937 PyObject * obj0 = 0 ;
38938 PyObject * obj1 = 0 ;
38939 char *kwnames[] = {
38940 (char *) "self",(char *) "show", NULL
38941 };
38942
38943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38945 if (SWIG_arg_fail(1)) SWIG_fail;
38946 {
38947 arg2 = (bool)(SWIG_As_bool(obj1));
38948 if (SWIG_arg_fail(2)) SWIG_fail;
38949 }
38950 {
38951 PyThreadState* __tstate = wxPyBeginAllowThreads();
38952 (arg1)->Show(arg2);
38953
38954 wxPyEndAllowThreads(__tstate);
38955 if (PyErr_Occurred()) SWIG_fail;
38956 }
38957 Py_INCREF(Py_None); resultobj = Py_None;
38958 return resultobj;
38959 fail:
38960 return NULL;
38961 }
38962
38963
38964 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38965 PyObject *resultobj;
38966 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38967 bool result;
38968 PyObject * obj0 = 0 ;
38969 char *kwnames[] = {
38970 (char *) "self", NULL
38971 };
38972
38973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38975 if (SWIG_arg_fail(1)) SWIG_fail;
38976 {
38977 PyThreadState* __tstate = wxPyBeginAllowThreads();
38978 result = (bool)(arg1)->IsShown();
38979
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 {
38984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38985 }
38986 return resultobj;
38987 fail:
38988 return NULL;
38989 }
38990
38991
38992 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj;
38994 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38995 wxPoint result;
38996 PyObject * obj0 = 0 ;
38997 char *kwnames[] = {
38998 (char *) "self", NULL
38999 };
39000
39001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39003 if (SWIG_arg_fail(1)) SWIG_fail;
39004 {
39005 PyThreadState* __tstate = wxPyBeginAllowThreads();
39006 result = (arg1)->GetPosition();
39007
39008 wxPyEndAllowThreads(__tstate);
39009 if (PyErr_Occurred()) SWIG_fail;
39010 }
39011 {
39012 wxPoint * resultptr;
39013 resultptr = new wxPoint((wxPoint &)(result));
39014 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39015 }
39016 return resultobj;
39017 fail:
39018 return NULL;
39019 }
39020
39021
39022 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39023 PyObject *resultobj;
39024 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39025 PyObject *result;
39026 PyObject * obj0 = 0 ;
39027 char *kwnames[] = {
39028 (char *) "self", NULL
39029 };
39030
39031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39033 if (SWIG_arg_fail(1)) SWIG_fail;
39034 {
39035 PyThreadState* __tstate = wxPyBeginAllowThreads();
39036 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39037
39038 wxPyEndAllowThreads(__tstate);
39039 if (PyErr_Occurred()) SWIG_fail;
39040 }
39041 resultobj = result;
39042 return resultobj;
39043 fail:
39044 return NULL;
39045 }
39046
39047
39048 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39049 PyObject *obj;
39050 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39051 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39052 Py_INCREF(obj);
39053 return Py_BuildValue((char *)"");
39054 }
39055 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39056 PyObject *resultobj;
39057 wxSizer *arg1 = (wxSizer *) 0 ;
39058 PyObject *arg2 = (PyObject *) 0 ;
39059 PyObject * obj0 = 0 ;
39060 PyObject * obj1 = 0 ;
39061 char *kwnames[] = {
39062 (char *) "self",(char *) "_self", NULL
39063 };
39064
39065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39067 if (SWIG_arg_fail(1)) SWIG_fail;
39068 arg2 = obj1;
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 wxSizer__setOORInfo(arg1,arg2);
39072
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 Py_INCREF(Py_None); resultobj = Py_None;
39077 return resultobj;
39078 fail:
39079 return NULL;
39080 }
39081
39082
39083 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39084 PyObject *resultobj;
39085 wxSizer *arg1 = (wxSizer *) 0 ;
39086 PyObject *arg2 = (PyObject *) 0 ;
39087 int arg3 = (int) 0 ;
39088 int arg4 = (int) 0 ;
39089 int arg5 = (int) 0 ;
39090 PyObject *arg6 = (PyObject *) NULL ;
39091 wxSizerItem *result;
39092 PyObject * obj0 = 0 ;
39093 PyObject * obj1 = 0 ;
39094 PyObject * obj2 = 0 ;
39095 PyObject * obj3 = 0 ;
39096 PyObject * obj4 = 0 ;
39097 PyObject * obj5 = 0 ;
39098 char *kwnames[] = {
39099 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39100 };
39101
39102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39104 if (SWIG_arg_fail(1)) SWIG_fail;
39105 arg2 = obj1;
39106 if (obj2) {
39107 {
39108 arg3 = (int)(SWIG_As_int(obj2));
39109 if (SWIG_arg_fail(3)) SWIG_fail;
39110 }
39111 }
39112 if (obj3) {
39113 {
39114 arg4 = (int)(SWIG_As_int(obj3));
39115 if (SWIG_arg_fail(4)) SWIG_fail;
39116 }
39117 }
39118 if (obj4) {
39119 {
39120 arg5 = (int)(SWIG_As_int(obj4));
39121 if (SWIG_arg_fail(5)) SWIG_fail;
39122 }
39123 }
39124 if (obj5) {
39125 arg6 = obj5;
39126 }
39127 {
39128 PyThreadState* __tstate = wxPyBeginAllowThreads();
39129 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39130
39131 wxPyEndAllowThreads(__tstate);
39132 if (PyErr_Occurred()) SWIG_fail;
39133 }
39134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39135 return resultobj;
39136 fail:
39137 return NULL;
39138 }
39139
39140
39141 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39142 PyObject *resultobj;
39143 wxSizer *arg1 = (wxSizer *) 0 ;
39144 int arg2 ;
39145 PyObject *arg3 = (PyObject *) 0 ;
39146 int arg4 = (int) 0 ;
39147 int arg5 = (int) 0 ;
39148 int arg6 = (int) 0 ;
39149 PyObject *arg7 = (PyObject *) NULL ;
39150 wxSizerItem *result;
39151 PyObject * obj0 = 0 ;
39152 PyObject * obj1 = 0 ;
39153 PyObject * obj2 = 0 ;
39154 PyObject * obj3 = 0 ;
39155 PyObject * obj4 = 0 ;
39156 PyObject * obj5 = 0 ;
39157 PyObject * obj6 = 0 ;
39158 char *kwnames[] = {
39159 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39160 };
39161
39162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39164 if (SWIG_arg_fail(1)) SWIG_fail;
39165 {
39166 arg2 = (int)(SWIG_As_int(obj1));
39167 if (SWIG_arg_fail(2)) SWIG_fail;
39168 }
39169 arg3 = obj2;
39170 if (obj3) {
39171 {
39172 arg4 = (int)(SWIG_As_int(obj3));
39173 if (SWIG_arg_fail(4)) SWIG_fail;
39174 }
39175 }
39176 if (obj4) {
39177 {
39178 arg5 = (int)(SWIG_As_int(obj4));
39179 if (SWIG_arg_fail(5)) SWIG_fail;
39180 }
39181 }
39182 if (obj5) {
39183 {
39184 arg6 = (int)(SWIG_As_int(obj5));
39185 if (SWIG_arg_fail(6)) SWIG_fail;
39186 }
39187 }
39188 if (obj6) {
39189 arg7 = obj6;
39190 }
39191 {
39192 PyThreadState* __tstate = wxPyBeginAllowThreads();
39193 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39194
39195 wxPyEndAllowThreads(__tstate);
39196 if (PyErr_Occurred()) SWIG_fail;
39197 }
39198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39199 return resultobj;
39200 fail:
39201 return NULL;
39202 }
39203
39204
39205 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39206 PyObject *resultobj;
39207 wxSizer *arg1 = (wxSizer *) 0 ;
39208 PyObject *arg2 = (PyObject *) 0 ;
39209 int arg3 = (int) 0 ;
39210 int arg4 = (int) 0 ;
39211 int arg5 = (int) 0 ;
39212 PyObject *arg6 = (PyObject *) NULL ;
39213 wxSizerItem *result;
39214 PyObject * obj0 = 0 ;
39215 PyObject * obj1 = 0 ;
39216 PyObject * obj2 = 0 ;
39217 PyObject * obj3 = 0 ;
39218 PyObject * obj4 = 0 ;
39219 PyObject * obj5 = 0 ;
39220 char *kwnames[] = {
39221 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39222 };
39223
39224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39226 if (SWIG_arg_fail(1)) SWIG_fail;
39227 arg2 = obj1;
39228 if (obj2) {
39229 {
39230 arg3 = (int)(SWIG_As_int(obj2));
39231 if (SWIG_arg_fail(3)) SWIG_fail;
39232 }
39233 }
39234 if (obj3) {
39235 {
39236 arg4 = (int)(SWIG_As_int(obj3));
39237 if (SWIG_arg_fail(4)) SWIG_fail;
39238 }
39239 }
39240 if (obj4) {
39241 {
39242 arg5 = (int)(SWIG_As_int(obj4));
39243 if (SWIG_arg_fail(5)) SWIG_fail;
39244 }
39245 }
39246 if (obj5) {
39247 arg6 = obj5;
39248 }
39249 {
39250 PyThreadState* __tstate = wxPyBeginAllowThreads();
39251 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39252
39253 wxPyEndAllowThreads(__tstate);
39254 if (PyErr_Occurred()) SWIG_fail;
39255 }
39256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39257 return resultobj;
39258 fail:
39259 return NULL;
39260 }
39261
39262
39263 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39264 PyObject *resultobj;
39265 wxSizer *arg1 = (wxSizer *) 0 ;
39266 PyObject *arg2 = (PyObject *) 0 ;
39267 bool result;
39268 PyObject * obj0 = 0 ;
39269 PyObject * obj1 = 0 ;
39270 char *kwnames[] = {
39271 (char *) "self",(char *) "item", NULL
39272 };
39273
39274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39276 if (SWIG_arg_fail(1)) SWIG_fail;
39277 arg2 = obj1;
39278 {
39279 PyThreadState* __tstate = wxPyBeginAllowThreads();
39280 result = (bool)wxSizer_Remove(arg1,arg2);
39281
39282 wxPyEndAllowThreads(__tstate);
39283 if (PyErr_Occurred()) SWIG_fail;
39284 }
39285 {
39286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39287 }
39288 return resultobj;
39289 fail:
39290 return NULL;
39291 }
39292
39293
39294 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39295 PyObject *resultobj;
39296 wxSizer *arg1 = (wxSizer *) 0 ;
39297 PyObject *arg2 = (PyObject *) 0 ;
39298 bool result;
39299 PyObject * obj0 = 0 ;
39300 PyObject * obj1 = 0 ;
39301 char *kwnames[] = {
39302 (char *) "self",(char *) "item", NULL
39303 };
39304
39305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39307 if (SWIG_arg_fail(1)) SWIG_fail;
39308 arg2 = obj1;
39309 {
39310 PyThreadState* __tstate = wxPyBeginAllowThreads();
39311 result = (bool)wxSizer_Detach(arg1,arg2);
39312
39313 wxPyEndAllowThreads(__tstate);
39314 if (PyErr_Occurred()) SWIG_fail;
39315 }
39316 {
39317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39318 }
39319 return resultobj;
39320 fail:
39321 return NULL;
39322 }
39323
39324
39325 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39326 PyObject *resultobj;
39327 wxSizer *arg1 = (wxSizer *) 0 ;
39328 PyObject *arg2 = (PyObject *) 0 ;
39329 wxSizerItem *result;
39330 PyObject * obj0 = 0 ;
39331 PyObject * obj1 = 0 ;
39332 char *kwnames[] = {
39333 (char *) "self",(char *) "item", NULL
39334 };
39335
39336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39338 if (SWIG_arg_fail(1)) SWIG_fail;
39339 arg2 = obj1;
39340 {
39341 PyThreadState* __tstate = wxPyBeginAllowThreads();
39342 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39343
39344 wxPyEndAllowThreads(__tstate);
39345 if (PyErr_Occurred()) SWIG_fail;
39346 }
39347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39348 return resultobj;
39349 fail:
39350 return NULL;
39351 }
39352
39353
39354 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39355 PyObject *resultobj;
39356 wxSizer *arg1 = (wxSizer *) 0 ;
39357 PyObject *arg2 = (PyObject *) 0 ;
39358 wxSize *arg3 = 0 ;
39359 wxSize temp3 ;
39360 PyObject * obj0 = 0 ;
39361 PyObject * obj1 = 0 ;
39362 PyObject * obj2 = 0 ;
39363 char *kwnames[] = {
39364 (char *) "self",(char *) "item",(char *) "size", NULL
39365 };
39366
39367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39369 if (SWIG_arg_fail(1)) SWIG_fail;
39370 arg2 = obj1;
39371 {
39372 arg3 = &temp3;
39373 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39374 }
39375 {
39376 PyThreadState* __tstate = wxPyBeginAllowThreads();
39377 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39378
39379 wxPyEndAllowThreads(__tstate);
39380 if (PyErr_Occurred()) SWIG_fail;
39381 }
39382 Py_INCREF(Py_None); resultobj = Py_None;
39383 return resultobj;
39384 fail:
39385 return NULL;
39386 }
39387
39388
39389 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39390 PyObject *resultobj;
39391 wxSizer *arg1 = (wxSizer *) 0 ;
39392 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39393 wxSizerItem *result;
39394 PyObject * obj0 = 0 ;
39395 PyObject * obj1 = 0 ;
39396 char *kwnames[] = {
39397 (char *) "self",(char *) "item", NULL
39398 };
39399
39400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39402 if (SWIG_arg_fail(1)) SWIG_fail;
39403 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39404 if (SWIG_arg_fail(2)) SWIG_fail;
39405 {
39406 PyThreadState* __tstate = wxPyBeginAllowThreads();
39407 result = (wxSizerItem *)(arg1)->Add(arg2);
39408
39409 wxPyEndAllowThreads(__tstate);
39410 if (PyErr_Occurred()) SWIG_fail;
39411 }
39412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39413 return resultobj;
39414 fail:
39415 return NULL;
39416 }
39417
39418
39419 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39420 PyObject *resultobj;
39421 wxSizer *arg1 = (wxSizer *) 0 ;
39422 size_t arg2 ;
39423 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39424 wxSizerItem *result;
39425 PyObject * obj0 = 0 ;
39426 PyObject * obj1 = 0 ;
39427 PyObject * obj2 = 0 ;
39428 char *kwnames[] = {
39429 (char *) "self",(char *) "index",(char *) "item", NULL
39430 };
39431
39432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39434 if (SWIG_arg_fail(1)) SWIG_fail;
39435 {
39436 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39437 if (SWIG_arg_fail(2)) SWIG_fail;
39438 }
39439 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39440 if (SWIG_arg_fail(3)) SWIG_fail;
39441 {
39442 PyThreadState* __tstate = wxPyBeginAllowThreads();
39443 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39444
39445 wxPyEndAllowThreads(__tstate);
39446 if (PyErr_Occurred()) SWIG_fail;
39447 }
39448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39449 return resultobj;
39450 fail:
39451 return NULL;
39452 }
39453
39454
39455 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39456 PyObject *resultobj;
39457 wxSizer *arg1 = (wxSizer *) 0 ;
39458 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39459 wxSizerItem *result;
39460 PyObject * obj0 = 0 ;
39461 PyObject * obj1 = 0 ;
39462 char *kwnames[] = {
39463 (char *) "self",(char *) "item", NULL
39464 };
39465
39466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39468 if (SWIG_arg_fail(1)) SWIG_fail;
39469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39470 if (SWIG_arg_fail(2)) SWIG_fail;
39471 {
39472 PyThreadState* __tstate = wxPyBeginAllowThreads();
39473 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39474
39475 wxPyEndAllowThreads(__tstate);
39476 if (PyErr_Occurred()) SWIG_fail;
39477 }
39478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39479 return resultobj;
39480 fail:
39481 return NULL;
39482 }
39483
39484
39485 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39486 PyObject *resultobj;
39487 wxSizer *arg1 = (wxSizer *) 0 ;
39488 int arg2 ;
39489 int arg3 ;
39490 int arg4 ;
39491 int arg5 ;
39492 PyObject * obj0 = 0 ;
39493 PyObject * obj1 = 0 ;
39494 PyObject * obj2 = 0 ;
39495 PyObject * obj3 = 0 ;
39496 PyObject * obj4 = 0 ;
39497 char *kwnames[] = {
39498 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39499 };
39500
39501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39503 if (SWIG_arg_fail(1)) SWIG_fail;
39504 {
39505 arg2 = (int)(SWIG_As_int(obj1));
39506 if (SWIG_arg_fail(2)) SWIG_fail;
39507 }
39508 {
39509 arg3 = (int)(SWIG_As_int(obj2));
39510 if (SWIG_arg_fail(3)) SWIG_fail;
39511 }
39512 {
39513 arg4 = (int)(SWIG_As_int(obj3));
39514 if (SWIG_arg_fail(4)) SWIG_fail;
39515 }
39516 {
39517 arg5 = (int)(SWIG_As_int(obj4));
39518 if (SWIG_arg_fail(5)) SWIG_fail;
39519 }
39520 {
39521 PyThreadState* __tstate = wxPyBeginAllowThreads();
39522 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39523
39524 wxPyEndAllowThreads(__tstate);
39525 if (PyErr_Occurred()) SWIG_fail;
39526 }
39527 Py_INCREF(Py_None); resultobj = Py_None;
39528 return resultobj;
39529 fail:
39530 return NULL;
39531 }
39532
39533
39534 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39535 PyObject *resultobj;
39536 wxSizer *arg1 = (wxSizer *) 0 ;
39537 wxSize *arg2 = 0 ;
39538 wxSize temp2 ;
39539 PyObject * obj0 = 0 ;
39540 PyObject * obj1 = 0 ;
39541 char *kwnames[] = {
39542 (char *) "self",(char *) "size", NULL
39543 };
39544
39545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39547 if (SWIG_arg_fail(1)) SWIG_fail;
39548 {
39549 arg2 = &temp2;
39550 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39551 }
39552 {
39553 PyThreadState* __tstate = wxPyBeginAllowThreads();
39554 (arg1)->SetMinSize((wxSize const &)*arg2);
39555
39556 wxPyEndAllowThreads(__tstate);
39557 if (PyErr_Occurred()) SWIG_fail;
39558 }
39559 Py_INCREF(Py_None); resultobj = Py_None;
39560 return resultobj;
39561 fail:
39562 return NULL;
39563 }
39564
39565
39566 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39567 PyObject *resultobj;
39568 wxSizer *arg1 = (wxSizer *) 0 ;
39569 wxSize result;
39570 PyObject * obj0 = 0 ;
39571 char *kwnames[] = {
39572 (char *) "self", NULL
39573 };
39574
39575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39577 if (SWIG_arg_fail(1)) SWIG_fail;
39578 {
39579 PyThreadState* __tstate = wxPyBeginAllowThreads();
39580 result = (arg1)->GetSize();
39581
39582 wxPyEndAllowThreads(__tstate);
39583 if (PyErr_Occurred()) SWIG_fail;
39584 }
39585 {
39586 wxSize * resultptr;
39587 resultptr = new wxSize((wxSize &)(result));
39588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39589 }
39590 return resultobj;
39591 fail:
39592 return NULL;
39593 }
39594
39595
39596 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39597 PyObject *resultobj;
39598 wxSizer *arg1 = (wxSizer *) 0 ;
39599 wxPoint result;
39600 PyObject * obj0 = 0 ;
39601 char *kwnames[] = {
39602 (char *) "self", NULL
39603 };
39604
39605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39607 if (SWIG_arg_fail(1)) SWIG_fail;
39608 {
39609 PyThreadState* __tstate = wxPyBeginAllowThreads();
39610 result = (arg1)->GetPosition();
39611
39612 wxPyEndAllowThreads(__tstate);
39613 if (PyErr_Occurred()) SWIG_fail;
39614 }
39615 {
39616 wxPoint * resultptr;
39617 resultptr = new wxPoint((wxPoint &)(result));
39618 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39619 }
39620 return resultobj;
39621 fail:
39622 return NULL;
39623 }
39624
39625
39626 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39627 PyObject *resultobj;
39628 wxSizer *arg1 = (wxSizer *) 0 ;
39629 wxSize result;
39630 PyObject * obj0 = 0 ;
39631 char *kwnames[] = {
39632 (char *) "self", NULL
39633 };
39634
39635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39637 if (SWIG_arg_fail(1)) SWIG_fail;
39638 {
39639 PyThreadState* __tstate = wxPyBeginAllowThreads();
39640 result = (arg1)->GetMinSize();
39641
39642 wxPyEndAllowThreads(__tstate);
39643 if (PyErr_Occurred()) SWIG_fail;
39644 }
39645 {
39646 wxSize * resultptr;
39647 resultptr = new wxSize((wxSize &)(result));
39648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39649 }
39650 return resultobj;
39651 fail:
39652 return NULL;
39653 }
39654
39655
39656 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39657 PyObject *resultobj;
39658 wxSizer *arg1 = (wxSizer *) 0 ;
39659 PyObject * obj0 = 0 ;
39660 char *kwnames[] = {
39661 (char *) "self", NULL
39662 };
39663
39664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39666 if (SWIG_arg_fail(1)) SWIG_fail;
39667 {
39668 PyThreadState* __tstate = wxPyBeginAllowThreads();
39669 (arg1)->RecalcSizes();
39670
39671 wxPyEndAllowThreads(__tstate);
39672 if (PyErr_Occurred()) SWIG_fail;
39673 }
39674 Py_INCREF(Py_None); resultobj = Py_None;
39675 return resultobj;
39676 fail:
39677 return NULL;
39678 }
39679
39680
39681 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39682 PyObject *resultobj;
39683 wxSizer *arg1 = (wxSizer *) 0 ;
39684 wxSize result;
39685 PyObject * obj0 = 0 ;
39686 char *kwnames[] = {
39687 (char *) "self", NULL
39688 };
39689
39690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39692 if (SWIG_arg_fail(1)) SWIG_fail;
39693 {
39694 PyThreadState* __tstate = wxPyBeginAllowThreads();
39695 result = (arg1)->CalcMin();
39696
39697 wxPyEndAllowThreads(__tstate);
39698 if (PyErr_Occurred()) SWIG_fail;
39699 }
39700 {
39701 wxSize * resultptr;
39702 resultptr = new wxSize((wxSize &)(result));
39703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39704 }
39705 return resultobj;
39706 fail:
39707 return NULL;
39708 }
39709
39710
39711 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39712 PyObject *resultobj;
39713 wxSizer *arg1 = (wxSizer *) 0 ;
39714 PyObject * obj0 = 0 ;
39715 char *kwnames[] = {
39716 (char *) "self", NULL
39717 };
39718
39719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39721 if (SWIG_arg_fail(1)) SWIG_fail;
39722 {
39723 PyThreadState* __tstate = wxPyBeginAllowThreads();
39724 (arg1)->Layout();
39725
39726 wxPyEndAllowThreads(__tstate);
39727 if (PyErr_Occurred()) SWIG_fail;
39728 }
39729 Py_INCREF(Py_None); resultobj = Py_None;
39730 return resultobj;
39731 fail:
39732 return NULL;
39733 }
39734
39735
39736 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39737 PyObject *resultobj;
39738 wxSizer *arg1 = (wxSizer *) 0 ;
39739 wxWindow *arg2 = (wxWindow *) 0 ;
39740 wxSize result;
39741 PyObject * obj0 = 0 ;
39742 PyObject * obj1 = 0 ;
39743 char *kwnames[] = {
39744 (char *) "self",(char *) "window", NULL
39745 };
39746
39747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39749 if (SWIG_arg_fail(1)) SWIG_fail;
39750 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39751 if (SWIG_arg_fail(2)) SWIG_fail;
39752 {
39753 PyThreadState* __tstate = wxPyBeginAllowThreads();
39754 result = (arg1)->Fit(arg2);
39755
39756 wxPyEndAllowThreads(__tstate);
39757 if (PyErr_Occurred()) SWIG_fail;
39758 }
39759 {
39760 wxSize * resultptr;
39761 resultptr = new wxSize((wxSize &)(result));
39762 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39763 }
39764 return resultobj;
39765 fail:
39766 return NULL;
39767 }
39768
39769
39770 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39771 PyObject *resultobj;
39772 wxSizer *arg1 = (wxSizer *) 0 ;
39773 wxWindow *arg2 = (wxWindow *) 0 ;
39774 PyObject * obj0 = 0 ;
39775 PyObject * obj1 = 0 ;
39776 char *kwnames[] = {
39777 (char *) "self",(char *) "window", NULL
39778 };
39779
39780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39782 if (SWIG_arg_fail(1)) SWIG_fail;
39783 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39784 if (SWIG_arg_fail(2)) SWIG_fail;
39785 {
39786 PyThreadState* __tstate = wxPyBeginAllowThreads();
39787 (arg1)->FitInside(arg2);
39788
39789 wxPyEndAllowThreads(__tstate);
39790 if (PyErr_Occurred()) SWIG_fail;
39791 }
39792 Py_INCREF(Py_None); resultobj = Py_None;
39793 return resultobj;
39794 fail:
39795 return NULL;
39796 }
39797
39798
39799 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39800 PyObject *resultobj;
39801 wxSizer *arg1 = (wxSizer *) 0 ;
39802 wxWindow *arg2 = (wxWindow *) 0 ;
39803 PyObject * obj0 = 0 ;
39804 PyObject * obj1 = 0 ;
39805 char *kwnames[] = {
39806 (char *) "self",(char *) "window", NULL
39807 };
39808
39809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39811 if (SWIG_arg_fail(1)) SWIG_fail;
39812 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39813 if (SWIG_arg_fail(2)) SWIG_fail;
39814 {
39815 PyThreadState* __tstate = wxPyBeginAllowThreads();
39816 (arg1)->SetSizeHints(arg2);
39817
39818 wxPyEndAllowThreads(__tstate);
39819 if (PyErr_Occurred()) SWIG_fail;
39820 }
39821 Py_INCREF(Py_None); resultobj = Py_None;
39822 return resultobj;
39823 fail:
39824 return NULL;
39825 }
39826
39827
39828 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39829 PyObject *resultobj;
39830 wxSizer *arg1 = (wxSizer *) 0 ;
39831 wxWindow *arg2 = (wxWindow *) 0 ;
39832 PyObject * obj0 = 0 ;
39833 PyObject * obj1 = 0 ;
39834 char *kwnames[] = {
39835 (char *) "self",(char *) "window", NULL
39836 };
39837
39838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39840 if (SWIG_arg_fail(1)) SWIG_fail;
39841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39842 if (SWIG_arg_fail(2)) SWIG_fail;
39843 {
39844 PyThreadState* __tstate = wxPyBeginAllowThreads();
39845 (arg1)->SetVirtualSizeHints(arg2);
39846
39847 wxPyEndAllowThreads(__tstate);
39848 if (PyErr_Occurred()) SWIG_fail;
39849 }
39850 Py_INCREF(Py_None); resultobj = Py_None;
39851 return resultobj;
39852 fail:
39853 return NULL;
39854 }
39855
39856
39857 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39858 PyObject *resultobj;
39859 wxSizer *arg1 = (wxSizer *) 0 ;
39860 bool arg2 = (bool) false ;
39861 PyObject * obj0 = 0 ;
39862 PyObject * obj1 = 0 ;
39863 char *kwnames[] = {
39864 (char *) "self",(char *) "deleteWindows", NULL
39865 };
39866
39867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39869 if (SWIG_arg_fail(1)) SWIG_fail;
39870 if (obj1) {
39871 {
39872 arg2 = (bool)(SWIG_As_bool(obj1));
39873 if (SWIG_arg_fail(2)) SWIG_fail;
39874 }
39875 }
39876 {
39877 PyThreadState* __tstate = wxPyBeginAllowThreads();
39878 (arg1)->Clear(arg2);
39879
39880 wxPyEndAllowThreads(__tstate);
39881 if (PyErr_Occurred()) SWIG_fail;
39882 }
39883 Py_INCREF(Py_None); resultobj = Py_None;
39884 return resultobj;
39885 fail:
39886 return NULL;
39887 }
39888
39889
39890 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39891 PyObject *resultobj;
39892 wxSizer *arg1 = (wxSizer *) 0 ;
39893 PyObject * obj0 = 0 ;
39894 char *kwnames[] = {
39895 (char *) "self", NULL
39896 };
39897
39898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39900 if (SWIG_arg_fail(1)) SWIG_fail;
39901 {
39902 PyThreadState* __tstate = wxPyBeginAllowThreads();
39903 (arg1)->DeleteWindows();
39904
39905 wxPyEndAllowThreads(__tstate);
39906 if (PyErr_Occurred()) SWIG_fail;
39907 }
39908 Py_INCREF(Py_None); resultobj = Py_None;
39909 return resultobj;
39910 fail:
39911 return NULL;
39912 }
39913
39914
39915 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39916 PyObject *resultobj;
39917 wxSizer *arg1 = (wxSizer *) 0 ;
39918 PyObject *result;
39919 PyObject * obj0 = 0 ;
39920 char *kwnames[] = {
39921 (char *) "self", NULL
39922 };
39923
39924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39926 if (SWIG_arg_fail(1)) SWIG_fail;
39927 {
39928 PyThreadState* __tstate = wxPyBeginAllowThreads();
39929 result = (PyObject *)wxSizer_GetChildren(arg1);
39930
39931 wxPyEndAllowThreads(__tstate);
39932 if (PyErr_Occurred()) SWIG_fail;
39933 }
39934 resultobj = result;
39935 return resultobj;
39936 fail:
39937 return NULL;
39938 }
39939
39940
39941 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39942 PyObject *resultobj;
39943 wxSizer *arg1 = (wxSizer *) 0 ;
39944 PyObject *arg2 = (PyObject *) 0 ;
39945 bool arg3 = (bool) true ;
39946 bool arg4 = (bool) false ;
39947 bool result;
39948 PyObject * obj0 = 0 ;
39949 PyObject * obj1 = 0 ;
39950 PyObject * obj2 = 0 ;
39951 PyObject * obj3 = 0 ;
39952 char *kwnames[] = {
39953 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39954 };
39955
39956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39958 if (SWIG_arg_fail(1)) SWIG_fail;
39959 arg2 = obj1;
39960 if (obj2) {
39961 {
39962 arg3 = (bool)(SWIG_As_bool(obj2));
39963 if (SWIG_arg_fail(3)) SWIG_fail;
39964 }
39965 }
39966 if (obj3) {
39967 {
39968 arg4 = (bool)(SWIG_As_bool(obj3));
39969 if (SWIG_arg_fail(4)) SWIG_fail;
39970 }
39971 }
39972 {
39973 PyThreadState* __tstate = wxPyBeginAllowThreads();
39974 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39975
39976 wxPyEndAllowThreads(__tstate);
39977 if (PyErr_Occurred()) SWIG_fail;
39978 }
39979 {
39980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39981 }
39982 return resultobj;
39983 fail:
39984 return NULL;
39985 }
39986
39987
39988 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39989 PyObject *resultobj;
39990 wxSizer *arg1 = (wxSizer *) 0 ;
39991 PyObject *arg2 = (PyObject *) 0 ;
39992 bool result;
39993 PyObject * obj0 = 0 ;
39994 PyObject * obj1 = 0 ;
39995 char *kwnames[] = {
39996 (char *) "self",(char *) "item", NULL
39997 };
39998
39999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40001 if (SWIG_arg_fail(1)) SWIG_fail;
40002 arg2 = obj1;
40003 {
40004 PyThreadState* __tstate = wxPyBeginAllowThreads();
40005 result = (bool)wxSizer_IsShown(arg1,arg2);
40006
40007 wxPyEndAllowThreads(__tstate);
40008 if (PyErr_Occurred()) SWIG_fail;
40009 }
40010 {
40011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40012 }
40013 return resultobj;
40014 fail:
40015 return NULL;
40016 }
40017
40018
40019 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40020 PyObject *resultobj;
40021 wxSizer *arg1 = (wxSizer *) 0 ;
40022 bool arg2 ;
40023 PyObject * obj0 = 0 ;
40024 PyObject * obj1 = 0 ;
40025 char *kwnames[] = {
40026 (char *) "self",(char *) "show", NULL
40027 };
40028
40029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40031 if (SWIG_arg_fail(1)) SWIG_fail;
40032 {
40033 arg2 = (bool)(SWIG_As_bool(obj1));
40034 if (SWIG_arg_fail(2)) SWIG_fail;
40035 }
40036 {
40037 PyThreadState* __tstate = wxPyBeginAllowThreads();
40038 (arg1)->ShowItems(arg2);
40039
40040 wxPyEndAllowThreads(__tstate);
40041 if (PyErr_Occurred()) SWIG_fail;
40042 }
40043 Py_INCREF(Py_None); resultobj = Py_None;
40044 return resultobj;
40045 fail:
40046 return NULL;
40047 }
40048
40049
40050 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40051 PyObject *obj;
40052 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40053 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40054 Py_INCREF(obj);
40055 return Py_BuildValue((char *)"");
40056 }
40057 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40058 PyObject *resultobj;
40059 wxPySizer *result;
40060 char *kwnames[] = {
40061 NULL
40062 };
40063
40064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40065 {
40066 PyThreadState* __tstate = wxPyBeginAllowThreads();
40067 result = (wxPySizer *)new wxPySizer();
40068
40069 wxPyEndAllowThreads(__tstate);
40070 if (PyErr_Occurred()) SWIG_fail;
40071 }
40072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40073 return resultobj;
40074 fail:
40075 return NULL;
40076 }
40077
40078
40079 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40080 PyObject *resultobj;
40081 wxPySizer *arg1 = (wxPySizer *) 0 ;
40082 PyObject *arg2 = (PyObject *) 0 ;
40083 PyObject *arg3 = (PyObject *) 0 ;
40084 PyObject * obj0 = 0 ;
40085 PyObject * obj1 = 0 ;
40086 PyObject * obj2 = 0 ;
40087 char *kwnames[] = {
40088 (char *) "self",(char *) "self",(char *) "_class", NULL
40089 };
40090
40091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40093 if (SWIG_arg_fail(1)) SWIG_fail;
40094 arg2 = obj1;
40095 arg3 = obj2;
40096 {
40097 PyThreadState* __tstate = wxPyBeginAllowThreads();
40098 (arg1)->_setCallbackInfo(arg2,arg3);
40099
40100 wxPyEndAllowThreads(__tstate);
40101 if (PyErr_Occurred()) SWIG_fail;
40102 }
40103 Py_INCREF(Py_None); resultobj = Py_None;
40104 return resultobj;
40105 fail:
40106 return NULL;
40107 }
40108
40109
40110 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40111 PyObject *obj;
40112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40113 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40114 Py_INCREF(obj);
40115 return Py_BuildValue((char *)"");
40116 }
40117 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40118 PyObject *resultobj;
40119 int arg1 = (int) wxHORIZONTAL ;
40120 wxBoxSizer *result;
40121 PyObject * obj0 = 0 ;
40122 char *kwnames[] = {
40123 (char *) "orient", NULL
40124 };
40125
40126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40127 if (obj0) {
40128 {
40129 arg1 = (int)(SWIG_As_int(obj0));
40130 if (SWIG_arg_fail(1)) SWIG_fail;
40131 }
40132 }
40133 {
40134 PyThreadState* __tstate = wxPyBeginAllowThreads();
40135 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40136
40137 wxPyEndAllowThreads(__tstate);
40138 if (PyErr_Occurred()) SWIG_fail;
40139 }
40140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40141 return resultobj;
40142 fail:
40143 return NULL;
40144 }
40145
40146
40147 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40148 PyObject *resultobj;
40149 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40150 int result;
40151 PyObject * obj0 = 0 ;
40152 char *kwnames[] = {
40153 (char *) "self", NULL
40154 };
40155
40156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40158 if (SWIG_arg_fail(1)) SWIG_fail;
40159 {
40160 PyThreadState* __tstate = wxPyBeginAllowThreads();
40161 result = (int)(arg1)->GetOrientation();
40162
40163 wxPyEndAllowThreads(__tstate);
40164 if (PyErr_Occurred()) SWIG_fail;
40165 }
40166 {
40167 resultobj = SWIG_From_int((int)(result));
40168 }
40169 return resultobj;
40170 fail:
40171 return NULL;
40172 }
40173
40174
40175 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40176 PyObject *resultobj;
40177 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40178 int arg2 ;
40179 PyObject * obj0 = 0 ;
40180 PyObject * obj1 = 0 ;
40181 char *kwnames[] = {
40182 (char *) "self",(char *) "orient", NULL
40183 };
40184
40185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40187 if (SWIG_arg_fail(1)) SWIG_fail;
40188 {
40189 arg2 = (int)(SWIG_As_int(obj1));
40190 if (SWIG_arg_fail(2)) SWIG_fail;
40191 }
40192 {
40193 PyThreadState* __tstate = wxPyBeginAllowThreads();
40194 (arg1)->SetOrientation(arg2);
40195
40196 wxPyEndAllowThreads(__tstate);
40197 if (PyErr_Occurred()) SWIG_fail;
40198 }
40199 Py_INCREF(Py_None); resultobj = Py_None;
40200 return resultobj;
40201 fail:
40202 return NULL;
40203 }
40204
40205
40206 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40207 PyObject *obj;
40208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40209 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40210 Py_INCREF(obj);
40211 return Py_BuildValue((char *)"");
40212 }
40213 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40214 PyObject *resultobj;
40215 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40216 int arg2 = (int) wxHORIZONTAL ;
40217 wxStaticBoxSizer *result;
40218 PyObject * obj0 = 0 ;
40219 PyObject * obj1 = 0 ;
40220 char *kwnames[] = {
40221 (char *) "box",(char *) "orient", NULL
40222 };
40223
40224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40226 if (SWIG_arg_fail(1)) SWIG_fail;
40227 if (obj1) {
40228 {
40229 arg2 = (int)(SWIG_As_int(obj1));
40230 if (SWIG_arg_fail(2)) SWIG_fail;
40231 }
40232 }
40233 {
40234 PyThreadState* __tstate = wxPyBeginAllowThreads();
40235 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40236
40237 wxPyEndAllowThreads(__tstate);
40238 if (PyErr_Occurred()) SWIG_fail;
40239 }
40240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40241 return resultobj;
40242 fail:
40243 return NULL;
40244 }
40245
40246
40247 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40248 PyObject *resultobj;
40249 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40250 wxStaticBox *result;
40251 PyObject * obj0 = 0 ;
40252 char *kwnames[] = {
40253 (char *) "self", NULL
40254 };
40255
40256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40258 if (SWIG_arg_fail(1)) SWIG_fail;
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 result = (wxStaticBox *)(arg1)->GetStaticBox();
40262
40263 wxPyEndAllowThreads(__tstate);
40264 if (PyErr_Occurred()) SWIG_fail;
40265 }
40266 {
40267 resultobj = wxPyMake_wxObject(result, 0);
40268 }
40269 return resultobj;
40270 fail:
40271 return NULL;
40272 }
40273
40274
40275 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40276 PyObject *obj;
40277 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40278 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40279 Py_INCREF(obj);
40280 return Py_BuildValue((char *)"");
40281 }
40282 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40283 PyObject *resultobj;
40284 int arg1 = (int) 1 ;
40285 int arg2 = (int) 0 ;
40286 int arg3 = (int) 0 ;
40287 int arg4 = (int) 0 ;
40288 wxGridSizer *result;
40289 PyObject * obj0 = 0 ;
40290 PyObject * obj1 = 0 ;
40291 PyObject * obj2 = 0 ;
40292 PyObject * obj3 = 0 ;
40293 char *kwnames[] = {
40294 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40295 };
40296
40297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40298 if (obj0) {
40299 {
40300 arg1 = (int)(SWIG_As_int(obj0));
40301 if (SWIG_arg_fail(1)) SWIG_fail;
40302 }
40303 }
40304 if (obj1) {
40305 {
40306 arg2 = (int)(SWIG_As_int(obj1));
40307 if (SWIG_arg_fail(2)) SWIG_fail;
40308 }
40309 }
40310 if (obj2) {
40311 {
40312 arg3 = (int)(SWIG_As_int(obj2));
40313 if (SWIG_arg_fail(3)) SWIG_fail;
40314 }
40315 }
40316 if (obj3) {
40317 {
40318 arg4 = (int)(SWIG_As_int(obj3));
40319 if (SWIG_arg_fail(4)) SWIG_fail;
40320 }
40321 }
40322 {
40323 PyThreadState* __tstate = wxPyBeginAllowThreads();
40324 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40325
40326 wxPyEndAllowThreads(__tstate);
40327 if (PyErr_Occurred()) SWIG_fail;
40328 }
40329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40330 return resultobj;
40331 fail:
40332 return NULL;
40333 }
40334
40335
40336 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40337 PyObject *resultobj;
40338 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40339 int arg2 ;
40340 PyObject * obj0 = 0 ;
40341 PyObject * obj1 = 0 ;
40342 char *kwnames[] = {
40343 (char *) "self",(char *) "cols", NULL
40344 };
40345
40346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40348 if (SWIG_arg_fail(1)) SWIG_fail;
40349 {
40350 arg2 = (int)(SWIG_As_int(obj1));
40351 if (SWIG_arg_fail(2)) SWIG_fail;
40352 }
40353 {
40354 PyThreadState* __tstate = wxPyBeginAllowThreads();
40355 (arg1)->SetCols(arg2);
40356
40357 wxPyEndAllowThreads(__tstate);
40358 if (PyErr_Occurred()) SWIG_fail;
40359 }
40360 Py_INCREF(Py_None); resultobj = Py_None;
40361 return resultobj;
40362 fail:
40363 return NULL;
40364 }
40365
40366
40367 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40368 PyObject *resultobj;
40369 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40370 int arg2 ;
40371 PyObject * obj0 = 0 ;
40372 PyObject * obj1 = 0 ;
40373 char *kwnames[] = {
40374 (char *) "self",(char *) "rows", NULL
40375 };
40376
40377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40379 if (SWIG_arg_fail(1)) SWIG_fail;
40380 {
40381 arg2 = (int)(SWIG_As_int(obj1));
40382 if (SWIG_arg_fail(2)) SWIG_fail;
40383 }
40384 {
40385 PyThreadState* __tstate = wxPyBeginAllowThreads();
40386 (arg1)->SetRows(arg2);
40387
40388 wxPyEndAllowThreads(__tstate);
40389 if (PyErr_Occurred()) SWIG_fail;
40390 }
40391 Py_INCREF(Py_None); resultobj = Py_None;
40392 return resultobj;
40393 fail:
40394 return NULL;
40395 }
40396
40397
40398 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40399 PyObject *resultobj;
40400 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40401 int arg2 ;
40402 PyObject * obj0 = 0 ;
40403 PyObject * obj1 = 0 ;
40404 char *kwnames[] = {
40405 (char *) "self",(char *) "gap", NULL
40406 };
40407
40408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40410 if (SWIG_arg_fail(1)) SWIG_fail;
40411 {
40412 arg2 = (int)(SWIG_As_int(obj1));
40413 if (SWIG_arg_fail(2)) SWIG_fail;
40414 }
40415 {
40416 PyThreadState* __tstate = wxPyBeginAllowThreads();
40417 (arg1)->SetVGap(arg2);
40418
40419 wxPyEndAllowThreads(__tstate);
40420 if (PyErr_Occurred()) SWIG_fail;
40421 }
40422 Py_INCREF(Py_None); resultobj = Py_None;
40423 return resultobj;
40424 fail:
40425 return NULL;
40426 }
40427
40428
40429 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40430 PyObject *resultobj;
40431 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40432 int arg2 ;
40433 PyObject * obj0 = 0 ;
40434 PyObject * obj1 = 0 ;
40435 char *kwnames[] = {
40436 (char *) "self",(char *) "gap", NULL
40437 };
40438
40439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40441 if (SWIG_arg_fail(1)) SWIG_fail;
40442 {
40443 arg2 = (int)(SWIG_As_int(obj1));
40444 if (SWIG_arg_fail(2)) SWIG_fail;
40445 }
40446 {
40447 PyThreadState* __tstate = wxPyBeginAllowThreads();
40448 (arg1)->SetHGap(arg2);
40449
40450 wxPyEndAllowThreads(__tstate);
40451 if (PyErr_Occurred()) SWIG_fail;
40452 }
40453 Py_INCREF(Py_None); resultobj = Py_None;
40454 return resultobj;
40455 fail:
40456 return NULL;
40457 }
40458
40459
40460 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40461 PyObject *resultobj;
40462 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40463 int result;
40464 PyObject * obj0 = 0 ;
40465 char *kwnames[] = {
40466 (char *) "self", NULL
40467 };
40468
40469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40471 if (SWIG_arg_fail(1)) SWIG_fail;
40472 {
40473 PyThreadState* __tstate = wxPyBeginAllowThreads();
40474 result = (int)(arg1)->GetCols();
40475
40476 wxPyEndAllowThreads(__tstate);
40477 if (PyErr_Occurred()) SWIG_fail;
40478 }
40479 {
40480 resultobj = SWIG_From_int((int)(result));
40481 }
40482 return resultobj;
40483 fail:
40484 return NULL;
40485 }
40486
40487
40488 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40489 PyObject *resultobj;
40490 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40491 int result;
40492 PyObject * obj0 = 0 ;
40493 char *kwnames[] = {
40494 (char *) "self", NULL
40495 };
40496
40497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40499 if (SWIG_arg_fail(1)) SWIG_fail;
40500 {
40501 PyThreadState* __tstate = wxPyBeginAllowThreads();
40502 result = (int)(arg1)->GetRows();
40503
40504 wxPyEndAllowThreads(__tstate);
40505 if (PyErr_Occurred()) SWIG_fail;
40506 }
40507 {
40508 resultobj = SWIG_From_int((int)(result));
40509 }
40510 return resultobj;
40511 fail:
40512 return NULL;
40513 }
40514
40515
40516 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40517 PyObject *resultobj;
40518 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40519 int result;
40520 PyObject * obj0 = 0 ;
40521 char *kwnames[] = {
40522 (char *) "self", NULL
40523 };
40524
40525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40527 if (SWIG_arg_fail(1)) SWIG_fail;
40528 {
40529 PyThreadState* __tstate = wxPyBeginAllowThreads();
40530 result = (int)(arg1)->GetVGap();
40531
40532 wxPyEndAllowThreads(__tstate);
40533 if (PyErr_Occurred()) SWIG_fail;
40534 }
40535 {
40536 resultobj = SWIG_From_int((int)(result));
40537 }
40538 return resultobj;
40539 fail:
40540 return NULL;
40541 }
40542
40543
40544 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40545 PyObject *resultobj;
40546 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40547 int result;
40548 PyObject * obj0 = 0 ;
40549 char *kwnames[] = {
40550 (char *) "self", NULL
40551 };
40552
40553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40555 if (SWIG_arg_fail(1)) SWIG_fail;
40556 {
40557 PyThreadState* __tstate = wxPyBeginAllowThreads();
40558 result = (int)(arg1)->GetHGap();
40559
40560 wxPyEndAllowThreads(__tstate);
40561 if (PyErr_Occurred()) SWIG_fail;
40562 }
40563 {
40564 resultobj = SWIG_From_int((int)(result));
40565 }
40566 return resultobj;
40567 fail:
40568 return NULL;
40569 }
40570
40571
40572 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40573 PyObject *obj;
40574 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40575 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40576 Py_INCREF(obj);
40577 return Py_BuildValue((char *)"");
40578 }
40579 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40580 PyObject *resultobj;
40581 int arg1 = (int) 1 ;
40582 int arg2 = (int) 0 ;
40583 int arg3 = (int) 0 ;
40584 int arg4 = (int) 0 ;
40585 wxFlexGridSizer *result;
40586 PyObject * obj0 = 0 ;
40587 PyObject * obj1 = 0 ;
40588 PyObject * obj2 = 0 ;
40589 PyObject * obj3 = 0 ;
40590 char *kwnames[] = {
40591 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40592 };
40593
40594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40595 if (obj0) {
40596 {
40597 arg1 = (int)(SWIG_As_int(obj0));
40598 if (SWIG_arg_fail(1)) SWIG_fail;
40599 }
40600 }
40601 if (obj1) {
40602 {
40603 arg2 = (int)(SWIG_As_int(obj1));
40604 if (SWIG_arg_fail(2)) SWIG_fail;
40605 }
40606 }
40607 if (obj2) {
40608 {
40609 arg3 = (int)(SWIG_As_int(obj2));
40610 if (SWIG_arg_fail(3)) SWIG_fail;
40611 }
40612 }
40613 if (obj3) {
40614 {
40615 arg4 = (int)(SWIG_As_int(obj3));
40616 if (SWIG_arg_fail(4)) SWIG_fail;
40617 }
40618 }
40619 {
40620 PyThreadState* __tstate = wxPyBeginAllowThreads();
40621 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40622
40623 wxPyEndAllowThreads(__tstate);
40624 if (PyErr_Occurred()) SWIG_fail;
40625 }
40626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40627 return resultobj;
40628 fail:
40629 return NULL;
40630 }
40631
40632
40633 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40634 PyObject *resultobj;
40635 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40636 size_t arg2 ;
40637 int arg3 = (int) 0 ;
40638 PyObject * obj0 = 0 ;
40639 PyObject * obj1 = 0 ;
40640 PyObject * obj2 = 0 ;
40641 char *kwnames[] = {
40642 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40643 };
40644
40645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40647 if (SWIG_arg_fail(1)) SWIG_fail;
40648 {
40649 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40650 if (SWIG_arg_fail(2)) SWIG_fail;
40651 }
40652 if (obj2) {
40653 {
40654 arg3 = (int)(SWIG_As_int(obj2));
40655 if (SWIG_arg_fail(3)) SWIG_fail;
40656 }
40657 }
40658 {
40659 PyThreadState* __tstate = wxPyBeginAllowThreads();
40660 (arg1)->AddGrowableRow(arg2,arg3);
40661
40662 wxPyEndAllowThreads(__tstate);
40663 if (PyErr_Occurred()) SWIG_fail;
40664 }
40665 Py_INCREF(Py_None); resultobj = Py_None;
40666 return resultobj;
40667 fail:
40668 return NULL;
40669 }
40670
40671
40672 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40673 PyObject *resultobj;
40674 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40675 size_t arg2 ;
40676 PyObject * obj0 = 0 ;
40677 PyObject * obj1 = 0 ;
40678 char *kwnames[] = {
40679 (char *) "self",(char *) "idx", NULL
40680 };
40681
40682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40684 if (SWIG_arg_fail(1)) SWIG_fail;
40685 {
40686 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40687 if (SWIG_arg_fail(2)) SWIG_fail;
40688 }
40689 {
40690 PyThreadState* __tstate = wxPyBeginAllowThreads();
40691 (arg1)->RemoveGrowableRow(arg2);
40692
40693 wxPyEndAllowThreads(__tstate);
40694 if (PyErr_Occurred()) SWIG_fail;
40695 }
40696 Py_INCREF(Py_None); resultobj = Py_None;
40697 return resultobj;
40698 fail:
40699 return NULL;
40700 }
40701
40702
40703 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40704 PyObject *resultobj;
40705 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40706 size_t arg2 ;
40707 int arg3 = (int) 0 ;
40708 PyObject * obj0 = 0 ;
40709 PyObject * obj1 = 0 ;
40710 PyObject * obj2 = 0 ;
40711 char *kwnames[] = {
40712 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40713 };
40714
40715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40717 if (SWIG_arg_fail(1)) SWIG_fail;
40718 {
40719 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40720 if (SWIG_arg_fail(2)) SWIG_fail;
40721 }
40722 if (obj2) {
40723 {
40724 arg3 = (int)(SWIG_As_int(obj2));
40725 if (SWIG_arg_fail(3)) SWIG_fail;
40726 }
40727 }
40728 {
40729 PyThreadState* __tstate = wxPyBeginAllowThreads();
40730 (arg1)->AddGrowableCol(arg2,arg3);
40731
40732 wxPyEndAllowThreads(__tstate);
40733 if (PyErr_Occurred()) SWIG_fail;
40734 }
40735 Py_INCREF(Py_None); resultobj = Py_None;
40736 return resultobj;
40737 fail:
40738 return NULL;
40739 }
40740
40741
40742 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40743 PyObject *resultobj;
40744 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40745 size_t arg2 ;
40746 PyObject * obj0 = 0 ;
40747 PyObject * obj1 = 0 ;
40748 char *kwnames[] = {
40749 (char *) "self",(char *) "idx", NULL
40750 };
40751
40752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40754 if (SWIG_arg_fail(1)) SWIG_fail;
40755 {
40756 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40757 if (SWIG_arg_fail(2)) SWIG_fail;
40758 }
40759 {
40760 PyThreadState* __tstate = wxPyBeginAllowThreads();
40761 (arg1)->RemoveGrowableCol(arg2);
40762
40763 wxPyEndAllowThreads(__tstate);
40764 if (PyErr_Occurred()) SWIG_fail;
40765 }
40766 Py_INCREF(Py_None); resultobj = Py_None;
40767 return resultobj;
40768 fail:
40769 return NULL;
40770 }
40771
40772
40773 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40774 PyObject *resultobj;
40775 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40776 int arg2 ;
40777 PyObject * obj0 = 0 ;
40778 PyObject * obj1 = 0 ;
40779 char *kwnames[] = {
40780 (char *) "self",(char *) "direction", NULL
40781 };
40782
40783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40785 if (SWIG_arg_fail(1)) SWIG_fail;
40786 {
40787 arg2 = (int)(SWIG_As_int(obj1));
40788 if (SWIG_arg_fail(2)) SWIG_fail;
40789 }
40790 {
40791 PyThreadState* __tstate = wxPyBeginAllowThreads();
40792 (arg1)->SetFlexibleDirection(arg2);
40793
40794 wxPyEndAllowThreads(__tstate);
40795 if (PyErr_Occurred()) SWIG_fail;
40796 }
40797 Py_INCREF(Py_None); resultobj = Py_None;
40798 return resultobj;
40799 fail:
40800 return NULL;
40801 }
40802
40803
40804 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40805 PyObject *resultobj;
40806 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40807 int result;
40808 PyObject * obj0 = 0 ;
40809 char *kwnames[] = {
40810 (char *) "self", NULL
40811 };
40812
40813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40815 if (SWIG_arg_fail(1)) SWIG_fail;
40816 {
40817 PyThreadState* __tstate = wxPyBeginAllowThreads();
40818 result = (int)(arg1)->GetFlexibleDirection();
40819
40820 wxPyEndAllowThreads(__tstate);
40821 if (PyErr_Occurred()) SWIG_fail;
40822 }
40823 {
40824 resultobj = SWIG_From_int((int)(result));
40825 }
40826 return resultobj;
40827 fail:
40828 return NULL;
40829 }
40830
40831
40832 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40833 PyObject *resultobj;
40834 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40835 wxFlexSizerGrowMode arg2 ;
40836 PyObject * obj0 = 0 ;
40837 PyObject * obj1 = 0 ;
40838 char *kwnames[] = {
40839 (char *) "self",(char *) "mode", NULL
40840 };
40841
40842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40844 if (SWIG_arg_fail(1)) SWIG_fail;
40845 {
40846 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40847 if (SWIG_arg_fail(2)) SWIG_fail;
40848 }
40849 {
40850 PyThreadState* __tstate = wxPyBeginAllowThreads();
40851 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40852
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 Py_INCREF(Py_None); resultobj = Py_None;
40857 return resultobj;
40858 fail:
40859 return NULL;
40860 }
40861
40862
40863 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40864 PyObject *resultobj;
40865 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40866 wxFlexSizerGrowMode result;
40867 PyObject * obj0 = 0 ;
40868 char *kwnames[] = {
40869 (char *) "self", NULL
40870 };
40871
40872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40874 if (SWIG_arg_fail(1)) SWIG_fail;
40875 {
40876 PyThreadState* __tstate = wxPyBeginAllowThreads();
40877 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40878
40879 wxPyEndAllowThreads(__tstate);
40880 if (PyErr_Occurred()) SWIG_fail;
40881 }
40882 resultobj = SWIG_From_int((result));
40883 return resultobj;
40884 fail:
40885 return NULL;
40886 }
40887
40888
40889 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40890 PyObject *resultobj;
40891 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40892 wxArrayInt *result;
40893 PyObject * obj0 = 0 ;
40894 char *kwnames[] = {
40895 (char *) "self", NULL
40896 };
40897
40898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40900 if (SWIG_arg_fail(1)) SWIG_fail;
40901 {
40902 PyThreadState* __tstate = wxPyBeginAllowThreads();
40903 {
40904 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40905 result = (wxArrayInt *) &_result_ref;
40906 }
40907
40908 wxPyEndAllowThreads(__tstate);
40909 if (PyErr_Occurred()) SWIG_fail;
40910 }
40911 {
40912 resultobj = PyList_New(0);
40913 size_t idx;
40914 for (idx = 0; idx < result->GetCount(); idx += 1) {
40915 PyObject* val = PyInt_FromLong( result->Item(idx) );
40916 PyList_Append(resultobj, val);
40917 Py_DECREF(val);
40918 }
40919 }
40920 return resultobj;
40921 fail:
40922 return NULL;
40923 }
40924
40925
40926 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40927 PyObject *resultobj;
40928 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40929 wxArrayInt *result;
40930 PyObject * obj0 = 0 ;
40931 char *kwnames[] = {
40932 (char *) "self", NULL
40933 };
40934
40935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40937 if (SWIG_arg_fail(1)) SWIG_fail;
40938 {
40939 PyThreadState* __tstate = wxPyBeginAllowThreads();
40940 {
40941 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40942 result = (wxArrayInt *) &_result_ref;
40943 }
40944
40945 wxPyEndAllowThreads(__tstate);
40946 if (PyErr_Occurred()) SWIG_fail;
40947 }
40948 {
40949 resultobj = PyList_New(0);
40950 size_t idx;
40951 for (idx = 0; idx < result->GetCount(); idx += 1) {
40952 PyObject* val = PyInt_FromLong( result->Item(idx) );
40953 PyList_Append(resultobj, val);
40954 Py_DECREF(val);
40955 }
40956 }
40957 return resultobj;
40958 fail:
40959 return NULL;
40960 }
40961
40962
40963 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40964 PyObject *obj;
40965 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40966 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40967 Py_INCREF(obj);
40968 return Py_BuildValue((char *)"");
40969 }
40970 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40971 PyObject *resultobj;
40972 wxStdDialogButtonSizer *result;
40973 char *kwnames[] = {
40974 NULL
40975 };
40976
40977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40978 {
40979 PyThreadState* __tstate = wxPyBeginAllowThreads();
40980 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40981
40982 wxPyEndAllowThreads(__tstate);
40983 if (PyErr_Occurred()) SWIG_fail;
40984 }
40985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40986 return resultobj;
40987 fail:
40988 return NULL;
40989 }
40990
40991
40992 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40993 PyObject *resultobj;
40994 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40995 wxButton *arg2 = (wxButton *) 0 ;
40996 PyObject * obj0 = 0 ;
40997 PyObject * obj1 = 0 ;
40998 char *kwnames[] = {
40999 (char *) "self",(char *) "button", NULL
41000 };
41001
41002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41004 if (SWIG_arg_fail(1)) SWIG_fail;
41005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41006 if (SWIG_arg_fail(2)) SWIG_fail;
41007 {
41008 PyThreadState* __tstate = wxPyBeginAllowThreads();
41009 (arg1)->AddButton(arg2);
41010
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 Py_INCREF(Py_None); resultobj = Py_None;
41015 return resultobj;
41016 fail:
41017 return NULL;
41018 }
41019
41020
41021 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41022 PyObject *resultobj;
41023 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41024 PyObject * obj0 = 0 ;
41025 char *kwnames[] = {
41026 (char *) "self", NULL
41027 };
41028
41029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41031 if (SWIG_arg_fail(1)) SWIG_fail;
41032 {
41033 PyThreadState* __tstate = wxPyBeginAllowThreads();
41034 (arg1)->Realize();
41035
41036 wxPyEndAllowThreads(__tstate);
41037 if (PyErr_Occurred()) SWIG_fail;
41038 }
41039 Py_INCREF(Py_None); resultobj = Py_None;
41040 return resultobj;
41041 fail:
41042 return NULL;
41043 }
41044
41045
41046 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41047 PyObject *resultobj;
41048 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41049 wxButton *arg2 = (wxButton *) 0 ;
41050 PyObject * obj0 = 0 ;
41051 PyObject * obj1 = 0 ;
41052 char *kwnames[] = {
41053 (char *) "self",(char *) "button", NULL
41054 };
41055
41056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41058 if (SWIG_arg_fail(1)) SWIG_fail;
41059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41060 if (SWIG_arg_fail(2)) SWIG_fail;
41061 {
41062 PyThreadState* __tstate = wxPyBeginAllowThreads();
41063 (arg1)->SetAffirmativeButton(arg2);
41064
41065 wxPyEndAllowThreads(__tstate);
41066 if (PyErr_Occurred()) SWIG_fail;
41067 }
41068 Py_INCREF(Py_None); resultobj = Py_None;
41069 return resultobj;
41070 fail:
41071 return NULL;
41072 }
41073
41074
41075 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41076 PyObject *resultobj;
41077 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41078 wxButton *arg2 = (wxButton *) 0 ;
41079 PyObject * obj0 = 0 ;
41080 PyObject * obj1 = 0 ;
41081 char *kwnames[] = {
41082 (char *) "self",(char *) "button", NULL
41083 };
41084
41085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41087 if (SWIG_arg_fail(1)) SWIG_fail;
41088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41089 if (SWIG_arg_fail(2)) SWIG_fail;
41090 {
41091 PyThreadState* __tstate = wxPyBeginAllowThreads();
41092 (arg1)->SetNegativeButton(arg2);
41093
41094 wxPyEndAllowThreads(__tstate);
41095 if (PyErr_Occurred()) SWIG_fail;
41096 }
41097 Py_INCREF(Py_None); resultobj = Py_None;
41098 return resultobj;
41099 fail:
41100 return NULL;
41101 }
41102
41103
41104 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41105 PyObject *resultobj;
41106 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41107 wxButton *arg2 = (wxButton *) 0 ;
41108 PyObject * obj0 = 0 ;
41109 PyObject * obj1 = 0 ;
41110 char *kwnames[] = {
41111 (char *) "self",(char *) "button", NULL
41112 };
41113
41114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41116 if (SWIG_arg_fail(1)) SWIG_fail;
41117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41118 if (SWIG_arg_fail(2)) SWIG_fail;
41119 {
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 (arg1)->SetCancelButton(arg2);
41122
41123 wxPyEndAllowThreads(__tstate);
41124 if (PyErr_Occurred()) SWIG_fail;
41125 }
41126 Py_INCREF(Py_None); resultobj = Py_None;
41127 return resultobj;
41128 fail:
41129 return NULL;
41130 }
41131
41132
41133 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41134 PyObject *resultobj;
41135 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41136 wxButton *result;
41137 PyObject * obj0 = 0 ;
41138 char *kwnames[] = {
41139 (char *) "self", NULL
41140 };
41141
41142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41144 if (SWIG_arg_fail(1)) SWIG_fail;
41145 {
41146 PyThreadState* __tstate = wxPyBeginAllowThreads();
41147 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41148
41149 wxPyEndAllowThreads(__tstate);
41150 if (PyErr_Occurred()) SWIG_fail;
41151 }
41152 {
41153 resultobj = wxPyMake_wxObject(result, 0);
41154 }
41155 return resultobj;
41156 fail:
41157 return NULL;
41158 }
41159
41160
41161 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41162 PyObject *resultobj;
41163 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41164 wxButton *result;
41165 PyObject * obj0 = 0 ;
41166 char *kwnames[] = {
41167 (char *) "self", NULL
41168 };
41169
41170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41172 if (SWIG_arg_fail(1)) SWIG_fail;
41173 {
41174 PyThreadState* __tstate = wxPyBeginAllowThreads();
41175 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41176
41177 wxPyEndAllowThreads(__tstate);
41178 if (PyErr_Occurred()) SWIG_fail;
41179 }
41180 {
41181 resultobj = wxPyMake_wxObject(result, 0);
41182 }
41183 return resultobj;
41184 fail:
41185 return NULL;
41186 }
41187
41188
41189 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41190 PyObject *resultobj;
41191 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41192 wxButton *result;
41193 PyObject * obj0 = 0 ;
41194 char *kwnames[] = {
41195 (char *) "self", NULL
41196 };
41197
41198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41200 if (SWIG_arg_fail(1)) SWIG_fail;
41201 {
41202 PyThreadState* __tstate = wxPyBeginAllowThreads();
41203 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41204
41205 wxPyEndAllowThreads(__tstate);
41206 if (PyErr_Occurred()) SWIG_fail;
41207 }
41208 {
41209 resultobj = wxPyMake_wxObject(result, 0);
41210 }
41211 return resultobj;
41212 fail:
41213 return NULL;
41214 }
41215
41216
41217 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41218 PyObject *resultobj;
41219 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41220 wxButton *result;
41221 PyObject * obj0 = 0 ;
41222 char *kwnames[] = {
41223 (char *) "self", NULL
41224 };
41225
41226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41228 if (SWIG_arg_fail(1)) SWIG_fail;
41229 {
41230 PyThreadState* __tstate = wxPyBeginAllowThreads();
41231 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41232
41233 wxPyEndAllowThreads(__tstate);
41234 if (PyErr_Occurred()) SWIG_fail;
41235 }
41236 {
41237 resultobj = wxPyMake_wxObject(result, 0);
41238 }
41239 return resultobj;
41240 fail:
41241 return NULL;
41242 }
41243
41244
41245 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41246 PyObject *resultobj;
41247 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41248 wxButton *result;
41249 PyObject * obj0 = 0 ;
41250 char *kwnames[] = {
41251 (char *) "self", NULL
41252 };
41253
41254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41256 if (SWIG_arg_fail(1)) SWIG_fail;
41257 {
41258 PyThreadState* __tstate = wxPyBeginAllowThreads();
41259 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41260
41261 wxPyEndAllowThreads(__tstate);
41262 if (PyErr_Occurred()) SWIG_fail;
41263 }
41264 {
41265 resultobj = wxPyMake_wxObject(result, 0);
41266 }
41267 return resultobj;
41268 fail:
41269 return NULL;
41270 }
41271
41272
41273 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41274 PyObject *obj;
41275 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41276 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41277 Py_INCREF(obj);
41278 return Py_BuildValue((char *)"");
41279 }
41280 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41281 PyObject *resultobj;
41282 int arg1 = (int) 0 ;
41283 int arg2 = (int) 0 ;
41284 wxGBPosition *result;
41285 PyObject * obj0 = 0 ;
41286 PyObject * obj1 = 0 ;
41287 char *kwnames[] = {
41288 (char *) "row",(char *) "col", NULL
41289 };
41290
41291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41292 if (obj0) {
41293 {
41294 arg1 = (int)(SWIG_As_int(obj0));
41295 if (SWIG_arg_fail(1)) SWIG_fail;
41296 }
41297 }
41298 if (obj1) {
41299 {
41300 arg2 = (int)(SWIG_As_int(obj1));
41301 if (SWIG_arg_fail(2)) SWIG_fail;
41302 }
41303 }
41304 {
41305 PyThreadState* __tstate = wxPyBeginAllowThreads();
41306 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41307
41308 wxPyEndAllowThreads(__tstate);
41309 if (PyErr_Occurred()) SWIG_fail;
41310 }
41311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41312 return resultobj;
41313 fail:
41314 return NULL;
41315 }
41316
41317
41318 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41319 PyObject *resultobj;
41320 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41321 int result;
41322 PyObject * obj0 = 0 ;
41323 char *kwnames[] = {
41324 (char *) "self", NULL
41325 };
41326
41327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41329 if (SWIG_arg_fail(1)) SWIG_fail;
41330 {
41331 PyThreadState* __tstate = wxPyBeginAllowThreads();
41332 result = (int)((wxGBPosition const *)arg1)->GetRow();
41333
41334 wxPyEndAllowThreads(__tstate);
41335 if (PyErr_Occurred()) SWIG_fail;
41336 }
41337 {
41338 resultobj = SWIG_From_int((int)(result));
41339 }
41340 return resultobj;
41341 fail:
41342 return NULL;
41343 }
41344
41345
41346 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41347 PyObject *resultobj;
41348 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41349 int result;
41350 PyObject * obj0 = 0 ;
41351 char *kwnames[] = {
41352 (char *) "self", NULL
41353 };
41354
41355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41357 if (SWIG_arg_fail(1)) SWIG_fail;
41358 {
41359 PyThreadState* __tstate = wxPyBeginAllowThreads();
41360 result = (int)((wxGBPosition const *)arg1)->GetCol();
41361
41362 wxPyEndAllowThreads(__tstate);
41363 if (PyErr_Occurred()) SWIG_fail;
41364 }
41365 {
41366 resultobj = SWIG_From_int((int)(result));
41367 }
41368 return resultobj;
41369 fail:
41370 return NULL;
41371 }
41372
41373
41374 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41375 PyObject *resultobj;
41376 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41377 int arg2 ;
41378 PyObject * obj0 = 0 ;
41379 PyObject * obj1 = 0 ;
41380 char *kwnames[] = {
41381 (char *) "self",(char *) "row", NULL
41382 };
41383
41384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41386 if (SWIG_arg_fail(1)) SWIG_fail;
41387 {
41388 arg2 = (int)(SWIG_As_int(obj1));
41389 if (SWIG_arg_fail(2)) SWIG_fail;
41390 }
41391 {
41392 PyThreadState* __tstate = wxPyBeginAllowThreads();
41393 (arg1)->SetRow(arg2);
41394
41395 wxPyEndAllowThreads(__tstate);
41396 if (PyErr_Occurred()) SWIG_fail;
41397 }
41398 Py_INCREF(Py_None); resultobj = Py_None;
41399 return resultobj;
41400 fail:
41401 return NULL;
41402 }
41403
41404
41405 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41406 PyObject *resultobj;
41407 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41408 int arg2 ;
41409 PyObject * obj0 = 0 ;
41410 PyObject * obj1 = 0 ;
41411 char *kwnames[] = {
41412 (char *) "self",(char *) "col", NULL
41413 };
41414
41415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41417 if (SWIG_arg_fail(1)) SWIG_fail;
41418 {
41419 arg2 = (int)(SWIG_As_int(obj1));
41420 if (SWIG_arg_fail(2)) SWIG_fail;
41421 }
41422 {
41423 PyThreadState* __tstate = wxPyBeginAllowThreads();
41424 (arg1)->SetCol(arg2);
41425
41426 wxPyEndAllowThreads(__tstate);
41427 if (PyErr_Occurred()) SWIG_fail;
41428 }
41429 Py_INCREF(Py_None); resultobj = Py_None;
41430 return resultobj;
41431 fail:
41432 return NULL;
41433 }
41434
41435
41436 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41437 PyObject *resultobj;
41438 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41439 wxGBPosition *arg2 = 0 ;
41440 bool result;
41441 wxGBPosition temp2 ;
41442 PyObject * obj0 = 0 ;
41443 PyObject * obj1 = 0 ;
41444 char *kwnames[] = {
41445 (char *) "self",(char *) "other", NULL
41446 };
41447
41448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41450 if (SWIG_arg_fail(1)) SWIG_fail;
41451 {
41452 arg2 = &temp2;
41453 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41454 }
41455 {
41456 PyThreadState* __tstate = wxPyBeginAllowThreads();
41457 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41458
41459 wxPyEndAllowThreads(__tstate);
41460 if (PyErr_Occurred()) SWIG_fail;
41461 }
41462 {
41463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41464 }
41465 return resultobj;
41466 fail:
41467 return NULL;
41468 }
41469
41470
41471 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41472 PyObject *resultobj;
41473 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41474 wxGBPosition *arg2 = 0 ;
41475 bool result;
41476 wxGBPosition temp2 ;
41477 PyObject * obj0 = 0 ;
41478 PyObject * obj1 = 0 ;
41479 char *kwnames[] = {
41480 (char *) "self",(char *) "other", NULL
41481 };
41482
41483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41485 if (SWIG_arg_fail(1)) SWIG_fail;
41486 {
41487 arg2 = &temp2;
41488 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41489 }
41490 {
41491 PyThreadState* __tstate = wxPyBeginAllowThreads();
41492 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41493
41494 wxPyEndAllowThreads(__tstate);
41495 if (PyErr_Occurred()) SWIG_fail;
41496 }
41497 {
41498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41499 }
41500 return resultobj;
41501 fail:
41502 return NULL;
41503 }
41504
41505
41506 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41507 PyObject *resultobj;
41508 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41509 int arg2 = (int) 0 ;
41510 int arg3 = (int) 0 ;
41511 PyObject * obj0 = 0 ;
41512 PyObject * obj1 = 0 ;
41513 PyObject * obj2 = 0 ;
41514 char *kwnames[] = {
41515 (char *) "self",(char *) "row",(char *) "col", NULL
41516 };
41517
41518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41520 if (SWIG_arg_fail(1)) SWIG_fail;
41521 if (obj1) {
41522 {
41523 arg2 = (int)(SWIG_As_int(obj1));
41524 if (SWIG_arg_fail(2)) SWIG_fail;
41525 }
41526 }
41527 if (obj2) {
41528 {
41529 arg3 = (int)(SWIG_As_int(obj2));
41530 if (SWIG_arg_fail(3)) SWIG_fail;
41531 }
41532 }
41533 {
41534 PyThreadState* __tstate = wxPyBeginAllowThreads();
41535 wxGBPosition_Set(arg1,arg2,arg3);
41536
41537 wxPyEndAllowThreads(__tstate);
41538 if (PyErr_Occurred()) SWIG_fail;
41539 }
41540 Py_INCREF(Py_None); resultobj = Py_None;
41541 return resultobj;
41542 fail:
41543 return NULL;
41544 }
41545
41546
41547 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41548 PyObject *resultobj;
41549 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41550 PyObject *result;
41551 PyObject * obj0 = 0 ;
41552 char *kwnames[] = {
41553 (char *) "self", NULL
41554 };
41555
41556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41558 if (SWIG_arg_fail(1)) SWIG_fail;
41559 {
41560 PyThreadState* __tstate = wxPyBeginAllowThreads();
41561 result = (PyObject *)wxGBPosition_Get(arg1);
41562
41563 wxPyEndAllowThreads(__tstate);
41564 if (PyErr_Occurred()) SWIG_fail;
41565 }
41566 resultobj = result;
41567 return resultobj;
41568 fail:
41569 return NULL;
41570 }
41571
41572
41573 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41574 PyObject *obj;
41575 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41576 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41577 Py_INCREF(obj);
41578 return Py_BuildValue((char *)"");
41579 }
41580 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41581 PyObject *resultobj;
41582 int arg1 = (int) 1 ;
41583 int arg2 = (int) 1 ;
41584 wxGBSpan *result;
41585 PyObject * obj0 = 0 ;
41586 PyObject * obj1 = 0 ;
41587 char *kwnames[] = {
41588 (char *) "rowspan",(char *) "colspan", NULL
41589 };
41590
41591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41592 if (obj0) {
41593 {
41594 arg1 = (int)(SWIG_As_int(obj0));
41595 if (SWIG_arg_fail(1)) SWIG_fail;
41596 }
41597 }
41598 if (obj1) {
41599 {
41600 arg2 = (int)(SWIG_As_int(obj1));
41601 if (SWIG_arg_fail(2)) SWIG_fail;
41602 }
41603 }
41604 {
41605 PyThreadState* __tstate = wxPyBeginAllowThreads();
41606 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41607
41608 wxPyEndAllowThreads(__tstate);
41609 if (PyErr_Occurred()) SWIG_fail;
41610 }
41611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41612 return resultobj;
41613 fail:
41614 return NULL;
41615 }
41616
41617
41618 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41619 PyObject *resultobj;
41620 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41621 int result;
41622 PyObject * obj0 = 0 ;
41623 char *kwnames[] = {
41624 (char *) "self", NULL
41625 };
41626
41627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41629 if (SWIG_arg_fail(1)) SWIG_fail;
41630 {
41631 PyThreadState* __tstate = wxPyBeginAllowThreads();
41632 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41633
41634 wxPyEndAllowThreads(__tstate);
41635 if (PyErr_Occurred()) SWIG_fail;
41636 }
41637 {
41638 resultobj = SWIG_From_int((int)(result));
41639 }
41640 return resultobj;
41641 fail:
41642 return NULL;
41643 }
41644
41645
41646 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41647 PyObject *resultobj;
41648 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41649 int result;
41650 PyObject * obj0 = 0 ;
41651 char *kwnames[] = {
41652 (char *) "self", NULL
41653 };
41654
41655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41657 if (SWIG_arg_fail(1)) SWIG_fail;
41658 {
41659 PyThreadState* __tstate = wxPyBeginAllowThreads();
41660 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41661
41662 wxPyEndAllowThreads(__tstate);
41663 if (PyErr_Occurred()) SWIG_fail;
41664 }
41665 {
41666 resultobj = SWIG_From_int((int)(result));
41667 }
41668 return resultobj;
41669 fail:
41670 return NULL;
41671 }
41672
41673
41674 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41675 PyObject *resultobj;
41676 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41677 int arg2 ;
41678 PyObject * obj0 = 0 ;
41679 PyObject * obj1 = 0 ;
41680 char *kwnames[] = {
41681 (char *) "self",(char *) "rowspan", NULL
41682 };
41683
41684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41686 if (SWIG_arg_fail(1)) SWIG_fail;
41687 {
41688 arg2 = (int)(SWIG_As_int(obj1));
41689 if (SWIG_arg_fail(2)) SWIG_fail;
41690 }
41691 {
41692 PyThreadState* __tstate = wxPyBeginAllowThreads();
41693 (arg1)->SetRowspan(arg2);
41694
41695 wxPyEndAllowThreads(__tstate);
41696 if (PyErr_Occurred()) SWIG_fail;
41697 }
41698 Py_INCREF(Py_None); resultobj = Py_None;
41699 return resultobj;
41700 fail:
41701 return NULL;
41702 }
41703
41704
41705 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41706 PyObject *resultobj;
41707 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41708 int arg2 ;
41709 PyObject * obj0 = 0 ;
41710 PyObject * obj1 = 0 ;
41711 char *kwnames[] = {
41712 (char *) "self",(char *) "colspan", NULL
41713 };
41714
41715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41717 if (SWIG_arg_fail(1)) SWIG_fail;
41718 {
41719 arg2 = (int)(SWIG_As_int(obj1));
41720 if (SWIG_arg_fail(2)) SWIG_fail;
41721 }
41722 {
41723 PyThreadState* __tstate = wxPyBeginAllowThreads();
41724 (arg1)->SetColspan(arg2);
41725
41726 wxPyEndAllowThreads(__tstate);
41727 if (PyErr_Occurred()) SWIG_fail;
41728 }
41729 Py_INCREF(Py_None); resultobj = Py_None;
41730 return resultobj;
41731 fail:
41732 return NULL;
41733 }
41734
41735
41736 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41737 PyObject *resultobj;
41738 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41739 wxGBSpan *arg2 = 0 ;
41740 bool result;
41741 wxGBSpan temp2 ;
41742 PyObject * obj0 = 0 ;
41743 PyObject * obj1 = 0 ;
41744 char *kwnames[] = {
41745 (char *) "self",(char *) "other", NULL
41746 };
41747
41748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41750 if (SWIG_arg_fail(1)) SWIG_fail;
41751 {
41752 arg2 = &temp2;
41753 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41754 }
41755 {
41756 PyThreadState* __tstate = wxPyBeginAllowThreads();
41757 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41758
41759 wxPyEndAllowThreads(__tstate);
41760 if (PyErr_Occurred()) SWIG_fail;
41761 }
41762 {
41763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41764 }
41765 return resultobj;
41766 fail:
41767 return NULL;
41768 }
41769
41770
41771 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41772 PyObject *resultobj;
41773 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41774 wxGBSpan *arg2 = 0 ;
41775 bool result;
41776 wxGBSpan temp2 ;
41777 PyObject * obj0 = 0 ;
41778 PyObject * obj1 = 0 ;
41779 char *kwnames[] = {
41780 (char *) "self",(char *) "other", NULL
41781 };
41782
41783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41785 if (SWIG_arg_fail(1)) SWIG_fail;
41786 {
41787 arg2 = &temp2;
41788 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41789 }
41790 {
41791 PyThreadState* __tstate = wxPyBeginAllowThreads();
41792 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41793
41794 wxPyEndAllowThreads(__tstate);
41795 if (PyErr_Occurred()) SWIG_fail;
41796 }
41797 {
41798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41799 }
41800 return resultobj;
41801 fail:
41802 return NULL;
41803 }
41804
41805
41806 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41807 PyObject *resultobj;
41808 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41809 int arg2 = (int) 1 ;
41810 int arg3 = (int) 1 ;
41811 PyObject * obj0 = 0 ;
41812 PyObject * obj1 = 0 ;
41813 PyObject * obj2 = 0 ;
41814 char *kwnames[] = {
41815 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41816 };
41817
41818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41820 if (SWIG_arg_fail(1)) SWIG_fail;
41821 if (obj1) {
41822 {
41823 arg2 = (int)(SWIG_As_int(obj1));
41824 if (SWIG_arg_fail(2)) SWIG_fail;
41825 }
41826 }
41827 if (obj2) {
41828 {
41829 arg3 = (int)(SWIG_As_int(obj2));
41830 if (SWIG_arg_fail(3)) SWIG_fail;
41831 }
41832 }
41833 {
41834 PyThreadState* __tstate = wxPyBeginAllowThreads();
41835 wxGBSpan_Set(arg1,arg2,arg3);
41836
41837 wxPyEndAllowThreads(__tstate);
41838 if (PyErr_Occurred()) SWIG_fail;
41839 }
41840 Py_INCREF(Py_None); resultobj = Py_None;
41841 return resultobj;
41842 fail:
41843 return NULL;
41844 }
41845
41846
41847 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41848 PyObject *resultobj;
41849 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41850 PyObject *result;
41851 PyObject * obj0 = 0 ;
41852 char *kwnames[] = {
41853 (char *) "self", NULL
41854 };
41855
41856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41858 if (SWIG_arg_fail(1)) SWIG_fail;
41859 {
41860 PyThreadState* __tstate = wxPyBeginAllowThreads();
41861 result = (PyObject *)wxGBSpan_Get(arg1);
41862
41863 wxPyEndAllowThreads(__tstate);
41864 if (PyErr_Occurred()) SWIG_fail;
41865 }
41866 resultobj = result;
41867 return resultobj;
41868 fail:
41869 return NULL;
41870 }
41871
41872
41873 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41874 PyObject *obj;
41875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41876 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41877 Py_INCREF(obj);
41878 return Py_BuildValue((char *)"");
41879 }
41880 static int _wrap_DefaultSpan_set(PyObject *) {
41881 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41882 return 1;
41883 }
41884
41885
41886 static PyObject *_wrap_DefaultSpan_get(void) {
41887 PyObject *pyobj;
41888
41889 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41890 return pyobj;
41891 }
41892
41893
41894 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41895 PyObject *resultobj;
41896 wxGBSizerItem *result;
41897 char *kwnames[] = {
41898 NULL
41899 };
41900
41901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41902 {
41903 PyThreadState* __tstate = wxPyBeginAllowThreads();
41904 result = (wxGBSizerItem *)new wxGBSizerItem();
41905
41906 wxPyEndAllowThreads(__tstate);
41907 if (PyErr_Occurred()) SWIG_fail;
41908 }
41909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41910 return resultobj;
41911 fail:
41912 return NULL;
41913 }
41914
41915
41916 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41917 PyObject *resultobj;
41918 wxWindow *arg1 = (wxWindow *) 0 ;
41919 wxGBPosition *arg2 = 0 ;
41920 wxGBSpan *arg3 = 0 ;
41921 int arg4 ;
41922 int arg5 ;
41923 PyObject *arg6 = (PyObject *) NULL ;
41924 wxGBSizerItem *result;
41925 wxGBPosition temp2 ;
41926 wxGBSpan temp3 ;
41927 PyObject * obj0 = 0 ;
41928 PyObject * obj1 = 0 ;
41929 PyObject * obj2 = 0 ;
41930 PyObject * obj3 = 0 ;
41931 PyObject * obj4 = 0 ;
41932 PyObject * obj5 = 0 ;
41933 char *kwnames[] = {
41934 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41935 };
41936
41937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41939 if (SWIG_arg_fail(1)) SWIG_fail;
41940 {
41941 arg2 = &temp2;
41942 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41943 }
41944 {
41945 arg3 = &temp3;
41946 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41947 }
41948 {
41949 arg4 = (int)(SWIG_As_int(obj3));
41950 if (SWIG_arg_fail(4)) SWIG_fail;
41951 }
41952 {
41953 arg5 = (int)(SWIG_As_int(obj4));
41954 if (SWIG_arg_fail(5)) SWIG_fail;
41955 }
41956 if (obj5) {
41957 arg6 = obj5;
41958 }
41959 {
41960 PyThreadState* __tstate = wxPyBeginAllowThreads();
41961 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41962
41963 wxPyEndAllowThreads(__tstate);
41964 if (PyErr_Occurred()) SWIG_fail;
41965 }
41966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41967 return resultobj;
41968 fail:
41969 return NULL;
41970 }
41971
41972
41973 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41974 PyObject *resultobj;
41975 wxSizer *arg1 = (wxSizer *) 0 ;
41976 wxGBPosition *arg2 = 0 ;
41977 wxGBSpan *arg3 = 0 ;
41978 int arg4 ;
41979 int arg5 ;
41980 PyObject *arg6 = (PyObject *) NULL ;
41981 wxGBSizerItem *result;
41982 wxGBPosition temp2 ;
41983 wxGBSpan temp3 ;
41984 PyObject * obj0 = 0 ;
41985 PyObject * obj1 = 0 ;
41986 PyObject * obj2 = 0 ;
41987 PyObject * obj3 = 0 ;
41988 PyObject * obj4 = 0 ;
41989 PyObject * obj5 = 0 ;
41990 char *kwnames[] = {
41991 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41992 };
41993
41994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41996 if (SWIG_arg_fail(1)) SWIG_fail;
41997 {
41998 arg2 = &temp2;
41999 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42000 }
42001 {
42002 arg3 = &temp3;
42003 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42004 }
42005 {
42006 arg4 = (int)(SWIG_As_int(obj3));
42007 if (SWIG_arg_fail(4)) SWIG_fail;
42008 }
42009 {
42010 arg5 = (int)(SWIG_As_int(obj4));
42011 if (SWIG_arg_fail(5)) SWIG_fail;
42012 }
42013 if (obj5) {
42014 arg6 = obj5;
42015 }
42016 {
42017 PyThreadState* __tstate = wxPyBeginAllowThreads();
42018 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42019
42020 wxPyEndAllowThreads(__tstate);
42021 if (PyErr_Occurred()) SWIG_fail;
42022 }
42023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42024 return resultobj;
42025 fail:
42026 return NULL;
42027 }
42028
42029
42030 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42031 PyObject *resultobj;
42032 int arg1 ;
42033 int arg2 ;
42034 wxGBPosition *arg3 = 0 ;
42035 wxGBSpan *arg4 = 0 ;
42036 int arg5 ;
42037 int arg6 ;
42038 PyObject *arg7 = (PyObject *) NULL ;
42039 wxGBSizerItem *result;
42040 wxGBPosition temp3 ;
42041 wxGBSpan temp4 ;
42042 PyObject * obj0 = 0 ;
42043 PyObject * obj1 = 0 ;
42044 PyObject * obj2 = 0 ;
42045 PyObject * obj3 = 0 ;
42046 PyObject * obj4 = 0 ;
42047 PyObject * obj5 = 0 ;
42048 PyObject * obj6 = 0 ;
42049 char *kwnames[] = {
42050 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42051 };
42052
42053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42054 {
42055 arg1 = (int)(SWIG_As_int(obj0));
42056 if (SWIG_arg_fail(1)) SWIG_fail;
42057 }
42058 {
42059 arg2 = (int)(SWIG_As_int(obj1));
42060 if (SWIG_arg_fail(2)) SWIG_fail;
42061 }
42062 {
42063 arg3 = &temp3;
42064 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42065 }
42066 {
42067 arg4 = &temp4;
42068 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42069 }
42070 {
42071 arg5 = (int)(SWIG_As_int(obj4));
42072 if (SWIG_arg_fail(5)) SWIG_fail;
42073 }
42074 {
42075 arg6 = (int)(SWIG_As_int(obj5));
42076 if (SWIG_arg_fail(6)) SWIG_fail;
42077 }
42078 if (obj6) {
42079 arg7 = obj6;
42080 }
42081 {
42082 PyThreadState* __tstate = wxPyBeginAllowThreads();
42083 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42084
42085 wxPyEndAllowThreads(__tstate);
42086 if (PyErr_Occurred()) SWIG_fail;
42087 }
42088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42089 return resultobj;
42090 fail:
42091 return NULL;
42092 }
42093
42094
42095 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42096 PyObject *resultobj;
42097 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42098 wxGBPosition result;
42099 PyObject * obj0 = 0 ;
42100 char *kwnames[] = {
42101 (char *) "self", NULL
42102 };
42103
42104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42106 if (SWIG_arg_fail(1)) SWIG_fail;
42107 {
42108 PyThreadState* __tstate = wxPyBeginAllowThreads();
42109 result = ((wxGBSizerItem const *)arg1)->GetPos();
42110
42111 wxPyEndAllowThreads(__tstate);
42112 if (PyErr_Occurred()) SWIG_fail;
42113 }
42114 {
42115 wxGBPosition * resultptr;
42116 resultptr = new wxGBPosition((wxGBPosition &)(result));
42117 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42118 }
42119 return resultobj;
42120 fail:
42121 return NULL;
42122 }
42123
42124
42125 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42126 PyObject *resultobj;
42127 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42128 wxGBSpan result;
42129 PyObject * obj0 = 0 ;
42130 char *kwnames[] = {
42131 (char *) "self", NULL
42132 };
42133
42134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42136 if (SWIG_arg_fail(1)) SWIG_fail;
42137 {
42138 PyThreadState* __tstate = wxPyBeginAllowThreads();
42139 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42140
42141 wxPyEndAllowThreads(__tstate);
42142 if (PyErr_Occurred()) SWIG_fail;
42143 }
42144 {
42145 wxGBSpan * resultptr;
42146 resultptr = new wxGBSpan((wxGBSpan &)(result));
42147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42148 }
42149 return resultobj;
42150 fail:
42151 return NULL;
42152 }
42153
42154
42155 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42156 PyObject *resultobj;
42157 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42158 wxGBPosition *arg2 = 0 ;
42159 bool result;
42160 wxGBPosition temp2 ;
42161 PyObject * obj0 = 0 ;
42162 PyObject * obj1 = 0 ;
42163 char *kwnames[] = {
42164 (char *) "self",(char *) "pos", NULL
42165 };
42166
42167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42169 if (SWIG_arg_fail(1)) SWIG_fail;
42170 {
42171 arg2 = &temp2;
42172 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42173 }
42174 {
42175 PyThreadState* __tstate = wxPyBeginAllowThreads();
42176 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42177
42178 wxPyEndAllowThreads(__tstate);
42179 if (PyErr_Occurred()) SWIG_fail;
42180 }
42181 {
42182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42183 }
42184 return resultobj;
42185 fail:
42186 return NULL;
42187 }
42188
42189
42190 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42191 PyObject *resultobj;
42192 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42193 wxGBSpan *arg2 = 0 ;
42194 bool result;
42195 wxGBSpan temp2 ;
42196 PyObject * obj0 = 0 ;
42197 PyObject * obj1 = 0 ;
42198 char *kwnames[] = {
42199 (char *) "self",(char *) "span", NULL
42200 };
42201
42202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42204 if (SWIG_arg_fail(1)) SWIG_fail;
42205 {
42206 arg2 = &temp2;
42207 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42208 }
42209 {
42210 PyThreadState* __tstate = wxPyBeginAllowThreads();
42211 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42212
42213 wxPyEndAllowThreads(__tstate);
42214 if (PyErr_Occurred()) SWIG_fail;
42215 }
42216 {
42217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42218 }
42219 return resultobj;
42220 fail:
42221 return NULL;
42222 }
42223
42224
42225 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42226 PyObject *resultobj;
42227 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42228 wxGBSizerItem *arg2 = 0 ;
42229 bool result;
42230 PyObject * obj0 = 0 ;
42231 PyObject * obj1 = 0 ;
42232 char *kwnames[] = {
42233 (char *) "self",(char *) "other", NULL
42234 };
42235
42236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42238 if (SWIG_arg_fail(1)) SWIG_fail;
42239 {
42240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42241 if (SWIG_arg_fail(2)) SWIG_fail;
42242 if (arg2 == NULL) {
42243 SWIG_null_ref("wxGBSizerItem");
42244 }
42245 if (SWIG_arg_fail(2)) SWIG_fail;
42246 }
42247 {
42248 PyThreadState* __tstate = wxPyBeginAllowThreads();
42249 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42250
42251 wxPyEndAllowThreads(__tstate);
42252 if (PyErr_Occurred()) SWIG_fail;
42253 }
42254 {
42255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42256 }
42257 return resultobj;
42258 fail:
42259 return NULL;
42260 }
42261
42262
42263 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42264 PyObject *resultobj;
42265 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42266 wxGBPosition *arg2 = 0 ;
42267 wxGBSpan *arg3 = 0 ;
42268 bool result;
42269 wxGBPosition temp2 ;
42270 wxGBSpan temp3 ;
42271 PyObject * obj0 = 0 ;
42272 PyObject * obj1 = 0 ;
42273 PyObject * obj2 = 0 ;
42274 char *kwnames[] = {
42275 (char *) "self",(char *) "pos",(char *) "span", NULL
42276 };
42277
42278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42280 if (SWIG_arg_fail(1)) SWIG_fail;
42281 {
42282 arg2 = &temp2;
42283 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42284 }
42285 {
42286 arg3 = &temp3;
42287 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42288 }
42289 {
42290 PyThreadState* __tstate = wxPyBeginAllowThreads();
42291 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42292
42293 wxPyEndAllowThreads(__tstate);
42294 if (PyErr_Occurred()) SWIG_fail;
42295 }
42296 {
42297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42298 }
42299 return resultobj;
42300 fail:
42301 return NULL;
42302 }
42303
42304
42305 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42306 PyObject *resultobj;
42307 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42308 wxGBPosition result;
42309 PyObject * obj0 = 0 ;
42310 char *kwnames[] = {
42311 (char *) "self", NULL
42312 };
42313
42314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42316 if (SWIG_arg_fail(1)) SWIG_fail;
42317 {
42318 PyThreadState* __tstate = wxPyBeginAllowThreads();
42319 result = wxGBSizerItem_GetEndPos(arg1);
42320
42321 wxPyEndAllowThreads(__tstate);
42322 if (PyErr_Occurred()) SWIG_fail;
42323 }
42324 {
42325 wxGBPosition * resultptr;
42326 resultptr = new wxGBPosition((wxGBPosition &)(result));
42327 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42328 }
42329 return resultobj;
42330 fail:
42331 return NULL;
42332 }
42333
42334
42335 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42336 PyObject *resultobj;
42337 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42338 wxGridBagSizer *result;
42339 PyObject * obj0 = 0 ;
42340 char *kwnames[] = {
42341 (char *) "self", NULL
42342 };
42343
42344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42346 if (SWIG_arg_fail(1)) SWIG_fail;
42347 {
42348 PyThreadState* __tstate = wxPyBeginAllowThreads();
42349 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42350
42351 wxPyEndAllowThreads(__tstate);
42352 if (PyErr_Occurred()) SWIG_fail;
42353 }
42354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42355 return resultobj;
42356 fail:
42357 return NULL;
42358 }
42359
42360
42361 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42362 PyObject *resultobj;
42363 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42364 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42365 PyObject * obj0 = 0 ;
42366 PyObject * obj1 = 0 ;
42367 char *kwnames[] = {
42368 (char *) "self",(char *) "sizer", NULL
42369 };
42370
42371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42373 if (SWIG_arg_fail(1)) SWIG_fail;
42374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42375 if (SWIG_arg_fail(2)) SWIG_fail;
42376 {
42377 PyThreadState* __tstate = wxPyBeginAllowThreads();
42378 (arg1)->SetGBSizer(arg2);
42379
42380 wxPyEndAllowThreads(__tstate);
42381 if (PyErr_Occurred()) SWIG_fail;
42382 }
42383 Py_INCREF(Py_None); resultobj = Py_None;
42384 return resultobj;
42385 fail:
42386 return NULL;
42387 }
42388
42389
42390 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42391 PyObject *obj;
42392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42393 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42394 Py_INCREF(obj);
42395 return Py_BuildValue((char *)"");
42396 }
42397 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42398 PyObject *resultobj;
42399 int arg1 = (int) 0 ;
42400 int arg2 = (int) 0 ;
42401 wxGridBagSizer *result;
42402 PyObject * obj0 = 0 ;
42403 PyObject * obj1 = 0 ;
42404 char *kwnames[] = {
42405 (char *) "vgap",(char *) "hgap", NULL
42406 };
42407
42408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42409 if (obj0) {
42410 {
42411 arg1 = (int)(SWIG_As_int(obj0));
42412 if (SWIG_arg_fail(1)) SWIG_fail;
42413 }
42414 }
42415 if (obj1) {
42416 {
42417 arg2 = (int)(SWIG_As_int(obj1));
42418 if (SWIG_arg_fail(2)) SWIG_fail;
42419 }
42420 }
42421 {
42422 PyThreadState* __tstate = wxPyBeginAllowThreads();
42423 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42424
42425 wxPyEndAllowThreads(__tstate);
42426 if (PyErr_Occurred()) SWIG_fail;
42427 }
42428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42429 return resultobj;
42430 fail:
42431 return NULL;
42432 }
42433
42434
42435 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42436 PyObject *resultobj;
42437 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42438 PyObject *arg2 = (PyObject *) 0 ;
42439 wxGBPosition *arg3 = 0 ;
42440 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42441 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42442 int arg5 = (int) 0 ;
42443 int arg6 = (int) 0 ;
42444 PyObject *arg7 = (PyObject *) NULL ;
42445 wxGBSizerItem *result;
42446 wxGBPosition temp3 ;
42447 wxGBSpan temp4 ;
42448 PyObject * obj0 = 0 ;
42449 PyObject * obj1 = 0 ;
42450 PyObject * obj2 = 0 ;
42451 PyObject * obj3 = 0 ;
42452 PyObject * obj4 = 0 ;
42453 PyObject * obj5 = 0 ;
42454 PyObject * obj6 = 0 ;
42455 char *kwnames[] = {
42456 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42457 };
42458
42459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42461 if (SWIG_arg_fail(1)) SWIG_fail;
42462 arg2 = obj1;
42463 {
42464 arg3 = &temp3;
42465 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42466 }
42467 if (obj3) {
42468 {
42469 arg4 = &temp4;
42470 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42471 }
42472 }
42473 if (obj4) {
42474 {
42475 arg5 = (int)(SWIG_As_int(obj4));
42476 if (SWIG_arg_fail(5)) SWIG_fail;
42477 }
42478 }
42479 if (obj5) {
42480 {
42481 arg6 = (int)(SWIG_As_int(obj5));
42482 if (SWIG_arg_fail(6)) SWIG_fail;
42483 }
42484 }
42485 if (obj6) {
42486 arg7 = obj6;
42487 }
42488 {
42489 PyThreadState* __tstate = wxPyBeginAllowThreads();
42490 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42491
42492 wxPyEndAllowThreads(__tstate);
42493 if (PyErr_Occurred()) SWIG_fail;
42494 }
42495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42496 return resultobj;
42497 fail:
42498 return NULL;
42499 }
42500
42501
42502 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42503 PyObject *resultobj;
42504 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42505 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42506 wxGBSizerItem *result;
42507 PyObject * obj0 = 0 ;
42508 PyObject * obj1 = 0 ;
42509 char *kwnames[] = {
42510 (char *) "self",(char *) "item", NULL
42511 };
42512
42513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42515 if (SWIG_arg_fail(1)) SWIG_fail;
42516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42517 if (SWIG_arg_fail(2)) SWIG_fail;
42518 {
42519 PyThreadState* __tstate = wxPyBeginAllowThreads();
42520 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42521
42522 wxPyEndAllowThreads(__tstate);
42523 if (PyErr_Occurred()) SWIG_fail;
42524 }
42525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42526 return resultobj;
42527 fail:
42528 return NULL;
42529 }
42530
42531
42532 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42533 PyObject *resultobj;
42534 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42535 int arg2 ;
42536 int arg3 ;
42537 wxSize result;
42538 PyObject * obj0 = 0 ;
42539 PyObject * obj1 = 0 ;
42540 PyObject * obj2 = 0 ;
42541 char *kwnames[] = {
42542 (char *) "self",(char *) "row",(char *) "col", NULL
42543 };
42544
42545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) 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 = (int)(SWIG_As_int(obj1));
42550 if (SWIG_arg_fail(2)) SWIG_fail;
42551 }
42552 {
42553 arg3 = (int)(SWIG_As_int(obj2));
42554 if (SWIG_arg_fail(3)) SWIG_fail;
42555 }
42556 {
42557 PyThreadState* __tstate = wxPyBeginAllowThreads();
42558 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42559
42560 wxPyEndAllowThreads(__tstate);
42561 if (PyErr_Occurred()) SWIG_fail;
42562 }
42563 {
42564 wxSize * resultptr;
42565 resultptr = new wxSize((wxSize &)(result));
42566 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42567 }
42568 return resultobj;
42569 fail:
42570 return NULL;
42571 }
42572
42573
42574 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42575 PyObject *resultobj;
42576 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42577 wxSize result;
42578 PyObject * obj0 = 0 ;
42579 char *kwnames[] = {
42580 (char *) "self", NULL
42581 };
42582
42583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42585 if (SWIG_arg_fail(1)) SWIG_fail;
42586 {
42587 PyThreadState* __tstate = wxPyBeginAllowThreads();
42588 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42589
42590 wxPyEndAllowThreads(__tstate);
42591 if (PyErr_Occurred()) SWIG_fail;
42592 }
42593 {
42594 wxSize * resultptr;
42595 resultptr = new wxSize((wxSize &)(result));
42596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42597 }
42598 return resultobj;
42599 fail:
42600 return NULL;
42601 }
42602
42603
42604 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42605 PyObject *resultobj;
42606 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42607 wxSize *arg2 = 0 ;
42608 wxSize temp2 ;
42609 PyObject * obj0 = 0 ;
42610 PyObject * obj1 = 0 ;
42611 char *kwnames[] = {
42612 (char *) "self",(char *) "sz", NULL
42613 };
42614
42615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42617 if (SWIG_arg_fail(1)) SWIG_fail;
42618 {
42619 arg2 = &temp2;
42620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42621 }
42622 {
42623 PyThreadState* __tstate = wxPyBeginAllowThreads();
42624 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42625
42626 wxPyEndAllowThreads(__tstate);
42627 if (PyErr_Occurred()) SWIG_fail;
42628 }
42629 Py_INCREF(Py_None); resultobj = Py_None;
42630 return resultobj;
42631 fail:
42632 return NULL;
42633 }
42634
42635
42636 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42637 PyObject *resultobj;
42638 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42639 wxWindow *arg2 = (wxWindow *) 0 ;
42640 wxGBPosition result;
42641 PyObject * obj0 = 0 ;
42642 PyObject * obj1 = 0 ;
42643
42644 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42646 if (SWIG_arg_fail(1)) SWIG_fail;
42647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42648 if (SWIG_arg_fail(2)) SWIG_fail;
42649 {
42650 PyThreadState* __tstate = wxPyBeginAllowThreads();
42651 result = (arg1)->GetItemPosition(arg2);
42652
42653 wxPyEndAllowThreads(__tstate);
42654 if (PyErr_Occurred()) SWIG_fail;
42655 }
42656 {
42657 wxGBPosition * resultptr;
42658 resultptr = new wxGBPosition((wxGBPosition &)(result));
42659 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42660 }
42661 return resultobj;
42662 fail:
42663 return NULL;
42664 }
42665
42666
42667 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42668 PyObject *resultobj;
42669 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42670 wxSizer *arg2 = (wxSizer *) 0 ;
42671 wxGBPosition result;
42672 PyObject * obj0 = 0 ;
42673 PyObject * obj1 = 0 ;
42674
42675 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42677 if (SWIG_arg_fail(1)) SWIG_fail;
42678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42679 if (SWIG_arg_fail(2)) SWIG_fail;
42680 {
42681 PyThreadState* __tstate = wxPyBeginAllowThreads();
42682 result = (arg1)->GetItemPosition(arg2);
42683
42684 wxPyEndAllowThreads(__tstate);
42685 if (PyErr_Occurred()) SWIG_fail;
42686 }
42687 {
42688 wxGBPosition * resultptr;
42689 resultptr = new wxGBPosition((wxGBPosition &)(result));
42690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42691 }
42692 return resultobj;
42693 fail:
42694 return NULL;
42695 }
42696
42697
42698 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42699 PyObject *resultobj;
42700 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42701 size_t arg2 ;
42702 wxGBPosition result;
42703 PyObject * obj0 = 0 ;
42704 PyObject * obj1 = 0 ;
42705
42706 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42708 if (SWIG_arg_fail(1)) SWIG_fail;
42709 {
42710 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42711 if (SWIG_arg_fail(2)) SWIG_fail;
42712 }
42713 {
42714 PyThreadState* __tstate = wxPyBeginAllowThreads();
42715 result = (arg1)->GetItemPosition(arg2);
42716
42717 wxPyEndAllowThreads(__tstate);
42718 if (PyErr_Occurred()) SWIG_fail;
42719 }
42720 {
42721 wxGBPosition * resultptr;
42722 resultptr = new wxGBPosition((wxGBPosition &)(result));
42723 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42724 }
42725 return resultobj;
42726 fail:
42727 return NULL;
42728 }
42729
42730
42731 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42732 int argc;
42733 PyObject *argv[3];
42734 int ii;
42735
42736 argc = PyObject_Length(args);
42737 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42738 argv[ii] = PyTuple_GetItem(args,ii);
42739 }
42740 if (argc == 2) {
42741 int _v;
42742 {
42743 void *ptr;
42744 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42745 _v = 0;
42746 PyErr_Clear();
42747 } else {
42748 _v = 1;
42749 }
42750 }
42751 if (_v) {
42752 {
42753 void *ptr;
42754 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42755 _v = 0;
42756 PyErr_Clear();
42757 } else {
42758 _v = 1;
42759 }
42760 }
42761 if (_v) {
42762 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42763 }
42764 }
42765 }
42766 if (argc == 2) {
42767 int _v;
42768 {
42769 void *ptr;
42770 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42771 _v = 0;
42772 PyErr_Clear();
42773 } else {
42774 _v = 1;
42775 }
42776 }
42777 if (_v) {
42778 {
42779 void *ptr;
42780 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42781 _v = 0;
42782 PyErr_Clear();
42783 } else {
42784 _v = 1;
42785 }
42786 }
42787 if (_v) {
42788 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42789 }
42790 }
42791 }
42792 if (argc == 2) {
42793 int _v;
42794 {
42795 void *ptr;
42796 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42797 _v = 0;
42798 PyErr_Clear();
42799 } else {
42800 _v = 1;
42801 }
42802 }
42803 if (_v) {
42804 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42805 if (_v) {
42806 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42807 }
42808 }
42809 }
42810
42811 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42812 return NULL;
42813 }
42814
42815
42816 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42817 PyObject *resultobj;
42818 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42819 wxWindow *arg2 = (wxWindow *) 0 ;
42820 wxGBPosition *arg3 = 0 ;
42821 bool result;
42822 wxGBPosition temp3 ;
42823 PyObject * obj0 = 0 ;
42824 PyObject * obj1 = 0 ;
42825 PyObject * obj2 = 0 ;
42826
42827 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42829 if (SWIG_arg_fail(1)) SWIG_fail;
42830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42831 if (SWIG_arg_fail(2)) SWIG_fail;
42832 {
42833 arg3 = &temp3;
42834 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42835 }
42836 {
42837 PyThreadState* __tstate = wxPyBeginAllowThreads();
42838 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42839
42840 wxPyEndAllowThreads(__tstate);
42841 if (PyErr_Occurred()) SWIG_fail;
42842 }
42843 {
42844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42845 }
42846 return resultobj;
42847 fail:
42848 return NULL;
42849 }
42850
42851
42852 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42853 PyObject *resultobj;
42854 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42855 wxSizer *arg2 = (wxSizer *) 0 ;
42856 wxGBPosition *arg3 = 0 ;
42857 bool result;
42858 wxGBPosition temp3 ;
42859 PyObject * obj0 = 0 ;
42860 PyObject * obj1 = 0 ;
42861 PyObject * obj2 = 0 ;
42862
42863 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42865 if (SWIG_arg_fail(1)) SWIG_fail;
42866 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42867 if (SWIG_arg_fail(2)) SWIG_fail;
42868 {
42869 arg3 = &temp3;
42870 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42871 }
42872 {
42873 PyThreadState* __tstate = wxPyBeginAllowThreads();
42874 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42875
42876 wxPyEndAllowThreads(__tstate);
42877 if (PyErr_Occurred()) SWIG_fail;
42878 }
42879 {
42880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42881 }
42882 return resultobj;
42883 fail:
42884 return NULL;
42885 }
42886
42887
42888 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42889 PyObject *resultobj;
42890 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42891 size_t arg2 ;
42892 wxGBPosition *arg3 = 0 ;
42893 bool result;
42894 wxGBPosition temp3 ;
42895 PyObject * obj0 = 0 ;
42896 PyObject * obj1 = 0 ;
42897 PyObject * obj2 = 0 ;
42898
42899 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42901 if (SWIG_arg_fail(1)) SWIG_fail;
42902 {
42903 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42904 if (SWIG_arg_fail(2)) SWIG_fail;
42905 }
42906 {
42907 arg3 = &temp3;
42908 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42909 }
42910 {
42911 PyThreadState* __tstate = wxPyBeginAllowThreads();
42912 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42913
42914 wxPyEndAllowThreads(__tstate);
42915 if (PyErr_Occurred()) SWIG_fail;
42916 }
42917 {
42918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42919 }
42920 return resultobj;
42921 fail:
42922 return NULL;
42923 }
42924
42925
42926 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42927 int argc;
42928 PyObject *argv[4];
42929 int ii;
42930
42931 argc = PyObject_Length(args);
42932 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42933 argv[ii] = PyTuple_GetItem(args,ii);
42934 }
42935 if (argc == 3) {
42936 int _v;
42937 {
42938 void *ptr;
42939 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42940 _v = 0;
42941 PyErr_Clear();
42942 } else {
42943 _v = 1;
42944 }
42945 }
42946 if (_v) {
42947 {
42948 void *ptr;
42949 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42950 _v = 0;
42951 PyErr_Clear();
42952 } else {
42953 _v = 1;
42954 }
42955 }
42956 if (_v) {
42957 {
42958 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42959 }
42960 if (_v) {
42961 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42962 }
42963 }
42964 }
42965 }
42966 if (argc == 3) {
42967 int _v;
42968 {
42969 void *ptr;
42970 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42971 _v = 0;
42972 PyErr_Clear();
42973 } else {
42974 _v = 1;
42975 }
42976 }
42977 if (_v) {
42978 {
42979 void *ptr;
42980 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42981 _v = 0;
42982 PyErr_Clear();
42983 } else {
42984 _v = 1;
42985 }
42986 }
42987 if (_v) {
42988 {
42989 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42990 }
42991 if (_v) {
42992 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42993 }
42994 }
42995 }
42996 }
42997 if (argc == 3) {
42998 int _v;
42999 {
43000 void *ptr;
43001 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43002 _v = 0;
43003 PyErr_Clear();
43004 } else {
43005 _v = 1;
43006 }
43007 }
43008 if (_v) {
43009 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43010 if (_v) {
43011 {
43012 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43013 }
43014 if (_v) {
43015 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43016 }
43017 }
43018 }
43019 }
43020
43021 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43022 return NULL;
43023 }
43024
43025
43026 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43027 PyObject *resultobj;
43028 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43029 wxWindow *arg2 = (wxWindow *) 0 ;
43030 wxGBSpan result;
43031 PyObject * obj0 = 0 ;
43032 PyObject * obj1 = 0 ;
43033
43034 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43036 if (SWIG_arg_fail(1)) SWIG_fail;
43037 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43038 if (SWIG_arg_fail(2)) SWIG_fail;
43039 {
43040 PyThreadState* __tstate = wxPyBeginAllowThreads();
43041 result = (arg1)->GetItemSpan(arg2);
43042
43043 wxPyEndAllowThreads(__tstate);
43044 if (PyErr_Occurred()) SWIG_fail;
43045 }
43046 {
43047 wxGBSpan * resultptr;
43048 resultptr = new wxGBSpan((wxGBSpan &)(result));
43049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43050 }
43051 return resultobj;
43052 fail:
43053 return NULL;
43054 }
43055
43056
43057 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43058 PyObject *resultobj;
43059 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43060 wxSizer *arg2 = (wxSizer *) 0 ;
43061 wxGBSpan result;
43062 PyObject * obj0 = 0 ;
43063 PyObject * obj1 = 0 ;
43064
43065 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43067 if (SWIG_arg_fail(1)) SWIG_fail;
43068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43069 if (SWIG_arg_fail(2)) SWIG_fail;
43070 {
43071 PyThreadState* __tstate = wxPyBeginAllowThreads();
43072 result = (arg1)->GetItemSpan(arg2);
43073
43074 wxPyEndAllowThreads(__tstate);
43075 if (PyErr_Occurred()) SWIG_fail;
43076 }
43077 {
43078 wxGBSpan * resultptr;
43079 resultptr = new wxGBSpan((wxGBSpan &)(result));
43080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43081 }
43082 return resultobj;
43083 fail:
43084 return NULL;
43085 }
43086
43087
43088 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43089 PyObject *resultobj;
43090 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43091 size_t arg2 ;
43092 wxGBSpan result;
43093 PyObject * obj0 = 0 ;
43094 PyObject * obj1 = 0 ;
43095
43096 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43098 if (SWIG_arg_fail(1)) SWIG_fail;
43099 {
43100 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43101 if (SWIG_arg_fail(2)) SWIG_fail;
43102 }
43103 {
43104 PyThreadState* __tstate = wxPyBeginAllowThreads();
43105 result = (arg1)->GetItemSpan(arg2);
43106
43107 wxPyEndAllowThreads(__tstate);
43108 if (PyErr_Occurred()) SWIG_fail;
43109 }
43110 {
43111 wxGBSpan * resultptr;
43112 resultptr = new wxGBSpan((wxGBSpan &)(result));
43113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43114 }
43115 return resultobj;
43116 fail:
43117 return NULL;
43118 }
43119
43120
43121 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43122 int argc;
43123 PyObject *argv[3];
43124 int ii;
43125
43126 argc = PyObject_Length(args);
43127 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43128 argv[ii] = PyTuple_GetItem(args,ii);
43129 }
43130 if (argc == 2) {
43131 int _v;
43132 {
43133 void *ptr;
43134 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43135 _v = 0;
43136 PyErr_Clear();
43137 } else {
43138 _v = 1;
43139 }
43140 }
43141 if (_v) {
43142 {
43143 void *ptr;
43144 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43145 _v = 0;
43146 PyErr_Clear();
43147 } else {
43148 _v = 1;
43149 }
43150 }
43151 if (_v) {
43152 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43153 }
43154 }
43155 }
43156 if (argc == 2) {
43157 int _v;
43158 {
43159 void *ptr;
43160 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43161 _v = 0;
43162 PyErr_Clear();
43163 } else {
43164 _v = 1;
43165 }
43166 }
43167 if (_v) {
43168 {
43169 void *ptr;
43170 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43171 _v = 0;
43172 PyErr_Clear();
43173 } else {
43174 _v = 1;
43175 }
43176 }
43177 if (_v) {
43178 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43179 }
43180 }
43181 }
43182 if (argc == 2) {
43183 int _v;
43184 {
43185 void *ptr;
43186 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43187 _v = 0;
43188 PyErr_Clear();
43189 } else {
43190 _v = 1;
43191 }
43192 }
43193 if (_v) {
43194 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43195 if (_v) {
43196 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43197 }
43198 }
43199 }
43200
43201 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43202 return NULL;
43203 }
43204
43205
43206 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43207 PyObject *resultobj;
43208 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43209 wxWindow *arg2 = (wxWindow *) 0 ;
43210 wxGBSpan *arg3 = 0 ;
43211 bool result;
43212 wxGBSpan temp3 ;
43213 PyObject * obj0 = 0 ;
43214 PyObject * obj1 = 0 ;
43215 PyObject * obj2 = 0 ;
43216
43217 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43219 if (SWIG_arg_fail(1)) SWIG_fail;
43220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43221 if (SWIG_arg_fail(2)) SWIG_fail;
43222 {
43223 arg3 = &temp3;
43224 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43225 }
43226 {
43227 PyThreadState* __tstate = wxPyBeginAllowThreads();
43228 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43229
43230 wxPyEndAllowThreads(__tstate);
43231 if (PyErr_Occurred()) SWIG_fail;
43232 }
43233 {
43234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43235 }
43236 return resultobj;
43237 fail:
43238 return NULL;
43239 }
43240
43241
43242 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43243 PyObject *resultobj;
43244 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43245 wxSizer *arg2 = (wxSizer *) 0 ;
43246 wxGBSpan *arg3 = 0 ;
43247 bool result;
43248 wxGBSpan temp3 ;
43249 PyObject * obj0 = 0 ;
43250 PyObject * obj1 = 0 ;
43251 PyObject * obj2 = 0 ;
43252
43253 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43255 if (SWIG_arg_fail(1)) SWIG_fail;
43256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43257 if (SWIG_arg_fail(2)) SWIG_fail;
43258 {
43259 arg3 = &temp3;
43260 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43261 }
43262 {
43263 PyThreadState* __tstate = wxPyBeginAllowThreads();
43264 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43265
43266 wxPyEndAllowThreads(__tstate);
43267 if (PyErr_Occurred()) SWIG_fail;
43268 }
43269 {
43270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43271 }
43272 return resultobj;
43273 fail:
43274 return NULL;
43275 }
43276
43277
43278 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43279 PyObject *resultobj;
43280 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43281 size_t arg2 ;
43282 wxGBSpan *arg3 = 0 ;
43283 bool result;
43284 wxGBSpan temp3 ;
43285 PyObject * obj0 = 0 ;
43286 PyObject * obj1 = 0 ;
43287 PyObject * obj2 = 0 ;
43288
43289 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43291 if (SWIG_arg_fail(1)) SWIG_fail;
43292 {
43293 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43294 if (SWIG_arg_fail(2)) SWIG_fail;
43295 }
43296 {
43297 arg3 = &temp3;
43298 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43299 }
43300 {
43301 PyThreadState* __tstate = wxPyBeginAllowThreads();
43302 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43303
43304 wxPyEndAllowThreads(__tstate);
43305 if (PyErr_Occurred()) SWIG_fail;
43306 }
43307 {
43308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43309 }
43310 return resultobj;
43311 fail:
43312 return NULL;
43313 }
43314
43315
43316 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43317 int argc;
43318 PyObject *argv[4];
43319 int ii;
43320
43321 argc = PyObject_Length(args);
43322 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43323 argv[ii] = PyTuple_GetItem(args,ii);
43324 }
43325 if (argc == 3) {
43326 int _v;
43327 {
43328 void *ptr;
43329 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43330 _v = 0;
43331 PyErr_Clear();
43332 } else {
43333 _v = 1;
43334 }
43335 }
43336 if (_v) {
43337 {
43338 void *ptr;
43339 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43340 _v = 0;
43341 PyErr_Clear();
43342 } else {
43343 _v = 1;
43344 }
43345 }
43346 if (_v) {
43347 {
43348 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43349 }
43350 if (_v) {
43351 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43352 }
43353 }
43354 }
43355 }
43356 if (argc == 3) {
43357 int _v;
43358 {
43359 void *ptr;
43360 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43361 _v = 0;
43362 PyErr_Clear();
43363 } else {
43364 _v = 1;
43365 }
43366 }
43367 if (_v) {
43368 {
43369 void *ptr;
43370 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43371 _v = 0;
43372 PyErr_Clear();
43373 } else {
43374 _v = 1;
43375 }
43376 }
43377 if (_v) {
43378 {
43379 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43380 }
43381 if (_v) {
43382 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43383 }
43384 }
43385 }
43386 }
43387 if (argc == 3) {
43388 int _v;
43389 {
43390 void *ptr;
43391 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43392 _v = 0;
43393 PyErr_Clear();
43394 } else {
43395 _v = 1;
43396 }
43397 }
43398 if (_v) {
43399 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43400 if (_v) {
43401 {
43402 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43403 }
43404 if (_v) {
43405 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43406 }
43407 }
43408 }
43409 }
43410
43411 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43412 return NULL;
43413 }
43414
43415
43416 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43417 PyObject *resultobj;
43418 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43419 wxWindow *arg2 = (wxWindow *) 0 ;
43420 wxGBSizerItem *result;
43421 PyObject * obj0 = 0 ;
43422 PyObject * obj1 = 0 ;
43423
43424 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43426 if (SWIG_arg_fail(1)) SWIG_fail;
43427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43428 if (SWIG_arg_fail(2)) SWIG_fail;
43429 {
43430 PyThreadState* __tstate = wxPyBeginAllowThreads();
43431 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43432
43433 wxPyEndAllowThreads(__tstate);
43434 if (PyErr_Occurred()) SWIG_fail;
43435 }
43436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43437 return resultobj;
43438 fail:
43439 return NULL;
43440 }
43441
43442
43443 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43444 PyObject *resultobj;
43445 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43446 wxSizer *arg2 = (wxSizer *) 0 ;
43447 wxGBSizerItem *result;
43448 PyObject * obj0 = 0 ;
43449 PyObject * obj1 = 0 ;
43450
43451 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43453 if (SWIG_arg_fail(1)) SWIG_fail;
43454 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43455 if (SWIG_arg_fail(2)) SWIG_fail;
43456 {
43457 PyThreadState* __tstate = wxPyBeginAllowThreads();
43458 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43459
43460 wxPyEndAllowThreads(__tstate);
43461 if (PyErr_Occurred()) SWIG_fail;
43462 }
43463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43464 return resultobj;
43465 fail:
43466 return NULL;
43467 }
43468
43469
43470 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43471 int argc;
43472 PyObject *argv[3];
43473 int ii;
43474
43475 argc = PyObject_Length(args);
43476 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43477 argv[ii] = PyTuple_GetItem(args,ii);
43478 }
43479 if (argc == 2) {
43480 int _v;
43481 {
43482 void *ptr;
43483 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43484 _v = 0;
43485 PyErr_Clear();
43486 } else {
43487 _v = 1;
43488 }
43489 }
43490 if (_v) {
43491 {
43492 void *ptr;
43493 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43494 _v = 0;
43495 PyErr_Clear();
43496 } else {
43497 _v = 1;
43498 }
43499 }
43500 if (_v) {
43501 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43502 }
43503 }
43504 }
43505 if (argc == 2) {
43506 int _v;
43507 {
43508 void *ptr;
43509 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43510 _v = 0;
43511 PyErr_Clear();
43512 } else {
43513 _v = 1;
43514 }
43515 }
43516 if (_v) {
43517 {
43518 void *ptr;
43519 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43520 _v = 0;
43521 PyErr_Clear();
43522 } else {
43523 _v = 1;
43524 }
43525 }
43526 if (_v) {
43527 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43528 }
43529 }
43530 }
43531
43532 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43533 return NULL;
43534 }
43535
43536
43537 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43538 PyObject *resultobj;
43539 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43540 wxGBPosition *arg2 = 0 ;
43541 wxGBSizerItem *result;
43542 wxGBPosition temp2 ;
43543 PyObject * obj0 = 0 ;
43544 PyObject * obj1 = 0 ;
43545 char *kwnames[] = {
43546 (char *) "self",(char *) "pos", NULL
43547 };
43548
43549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43551 if (SWIG_arg_fail(1)) SWIG_fail;
43552 {
43553 arg2 = &temp2;
43554 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43555 }
43556 {
43557 PyThreadState* __tstate = wxPyBeginAllowThreads();
43558 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43559
43560 wxPyEndAllowThreads(__tstate);
43561 if (PyErr_Occurred()) SWIG_fail;
43562 }
43563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43564 return resultobj;
43565 fail:
43566 return NULL;
43567 }
43568
43569
43570 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43571 PyObject *resultobj;
43572 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43573 wxPoint *arg2 = 0 ;
43574 wxGBSizerItem *result;
43575 wxPoint temp2 ;
43576 PyObject * obj0 = 0 ;
43577 PyObject * obj1 = 0 ;
43578 char *kwnames[] = {
43579 (char *) "self",(char *) "pt", NULL
43580 };
43581
43582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43584 if (SWIG_arg_fail(1)) SWIG_fail;
43585 {
43586 arg2 = &temp2;
43587 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43588 }
43589 {
43590 PyThreadState* __tstate = wxPyBeginAllowThreads();
43591 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43592
43593 wxPyEndAllowThreads(__tstate);
43594 if (PyErr_Occurred()) SWIG_fail;
43595 }
43596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43597 return resultobj;
43598 fail:
43599 return NULL;
43600 }
43601
43602
43603 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43604 PyObject *resultobj;
43605 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43606 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43607 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43608 bool result;
43609 PyObject * obj0 = 0 ;
43610 PyObject * obj1 = 0 ;
43611 PyObject * obj2 = 0 ;
43612 char *kwnames[] = {
43613 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43614 };
43615
43616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43618 if (SWIG_arg_fail(1)) SWIG_fail;
43619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43620 if (SWIG_arg_fail(2)) SWIG_fail;
43621 if (obj2) {
43622 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43623 if (SWIG_arg_fail(3)) SWIG_fail;
43624 }
43625 {
43626 PyThreadState* __tstate = wxPyBeginAllowThreads();
43627 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43628
43629 wxPyEndAllowThreads(__tstate);
43630 if (PyErr_Occurred()) SWIG_fail;
43631 }
43632 {
43633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43634 }
43635 return resultobj;
43636 fail:
43637 return NULL;
43638 }
43639
43640
43641 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43642 PyObject *resultobj;
43643 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43644 wxGBPosition *arg2 = 0 ;
43645 wxGBSpan *arg3 = 0 ;
43646 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43647 bool result;
43648 wxGBPosition temp2 ;
43649 wxGBSpan temp3 ;
43650 PyObject * obj0 = 0 ;
43651 PyObject * obj1 = 0 ;
43652 PyObject * obj2 = 0 ;
43653 PyObject * obj3 = 0 ;
43654 char *kwnames[] = {
43655 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43656 };
43657
43658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43660 if (SWIG_arg_fail(1)) SWIG_fail;
43661 {
43662 arg2 = &temp2;
43663 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43664 }
43665 {
43666 arg3 = &temp3;
43667 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43668 }
43669 if (obj3) {
43670 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43671 if (SWIG_arg_fail(4)) SWIG_fail;
43672 }
43673 {
43674 PyThreadState* __tstate = wxPyBeginAllowThreads();
43675 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43676
43677 wxPyEndAllowThreads(__tstate);
43678 if (PyErr_Occurred()) SWIG_fail;
43679 }
43680 {
43681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43682 }
43683 return resultobj;
43684 fail:
43685 return NULL;
43686 }
43687
43688
43689 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43690 PyObject *obj;
43691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43692 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43693 Py_INCREF(obj);
43694 return Py_BuildValue((char *)"");
43695 }
43696 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43697 PyObject *resultobj;
43698 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43699 wxRelationship arg2 ;
43700 wxWindow *arg3 = (wxWindow *) 0 ;
43701 wxEdge arg4 ;
43702 int arg5 = (int) 0 ;
43703 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43704 PyObject * obj0 = 0 ;
43705 PyObject * obj1 = 0 ;
43706 PyObject * obj2 = 0 ;
43707 PyObject * obj3 = 0 ;
43708 PyObject * obj4 = 0 ;
43709 PyObject * obj5 = 0 ;
43710 char *kwnames[] = {
43711 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43712 };
43713
43714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43716 if (SWIG_arg_fail(1)) SWIG_fail;
43717 {
43718 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43719 if (SWIG_arg_fail(2)) SWIG_fail;
43720 }
43721 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43722 if (SWIG_arg_fail(3)) SWIG_fail;
43723 {
43724 arg4 = (wxEdge)(SWIG_As_int(obj3));
43725 if (SWIG_arg_fail(4)) SWIG_fail;
43726 }
43727 if (obj4) {
43728 {
43729 arg5 = (int)(SWIG_As_int(obj4));
43730 if (SWIG_arg_fail(5)) SWIG_fail;
43731 }
43732 }
43733 if (obj5) {
43734 {
43735 arg6 = (int)(SWIG_As_int(obj5));
43736 if (SWIG_arg_fail(6)) SWIG_fail;
43737 }
43738 }
43739 {
43740 PyThreadState* __tstate = wxPyBeginAllowThreads();
43741 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43742
43743 wxPyEndAllowThreads(__tstate);
43744 if (PyErr_Occurred()) SWIG_fail;
43745 }
43746 Py_INCREF(Py_None); resultobj = Py_None;
43747 return resultobj;
43748 fail:
43749 return NULL;
43750 }
43751
43752
43753 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43754 PyObject *resultobj;
43755 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43756 wxWindow *arg2 = (wxWindow *) 0 ;
43757 int arg3 = (int) 0 ;
43758 PyObject * obj0 = 0 ;
43759 PyObject * obj1 = 0 ;
43760 PyObject * obj2 = 0 ;
43761 char *kwnames[] = {
43762 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43763 };
43764
43765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43767 if (SWIG_arg_fail(1)) SWIG_fail;
43768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43769 if (SWIG_arg_fail(2)) SWIG_fail;
43770 if (obj2) {
43771 {
43772 arg3 = (int)(SWIG_As_int(obj2));
43773 if (SWIG_arg_fail(3)) SWIG_fail;
43774 }
43775 }
43776 {
43777 PyThreadState* __tstate = wxPyBeginAllowThreads();
43778 (arg1)->LeftOf(arg2,arg3);
43779
43780 wxPyEndAllowThreads(__tstate);
43781 if (PyErr_Occurred()) SWIG_fail;
43782 }
43783 Py_INCREF(Py_None); resultobj = Py_None;
43784 return resultobj;
43785 fail:
43786 return NULL;
43787 }
43788
43789
43790 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43791 PyObject *resultobj;
43792 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43793 wxWindow *arg2 = (wxWindow *) 0 ;
43794 int arg3 = (int) 0 ;
43795 PyObject * obj0 = 0 ;
43796 PyObject * obj1 = 0 ;
43797 PyObject * obj2 = 0 ;
43798 char *kwnames[] = {
43799 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43800 };
43801
43802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43804 if (SWIG_arg_fail(1)) SWIG_fail;
43805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43806 if (SWIG_arg_fail(2)) SWIG_fail;
43807 if (obj2) {
43808 {
43809 arg3 = (int)(SWIG_As_int(obj2));
43810 if (SWIG_arg_fail(3)) SWIG_fail;
43811 }
43812 }
43813 {
43814 PyThreadState* __tstate = wxPyBeginAllowThreads();
43815 (arg1)->RightOf(arg2,arg3);
43816
43817 wxPyEndAllowThreads(__tstate);
43818 if (PyErr_Occurred()) SWIG_fail;
43819 }
43820 Py_INCREF(Py_None); resultobj = Py_None;
43821 return resultobj;
43822 fail:
43823 return NULL;
43824 }
43825
43826
43827 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43828 PyObject *resultobj;
43829 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43830 wxWindow *arg2 = (wxWindow *) 0 ;
43831 int arg3 = (int) 0 ;
43832 PyObject * obj0 = 0 ;
43833 PyObject * obj1 = 0 ;
43834 PyObject * obj2 = 0 ;
43835 char *kwnames[] = {
43836 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43837 };
43838
43839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43841 if (SWIG_arg_fail(1)) SWIG_fail;
43842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43843 if (SWIG_arg_fail(2)) SWIG_fail;
43844 if (obj2) {
43845 {
43846 arg3 = (int)(SWIG_As_int(obj2));
43847 if (SWIG_arg_fail(3)) SWIG_fail;
43848 }
43849 }
43850 {
43851 PyThreadState* __tstate = wxPyBeginAllowThreads();
43852 (arg1)->Above(arg2,arg3);
43853
43854 wxPyEndAllowThreads(__tstate);
43855 if (PyErr_Occurred()) SWIG_fail;
43856 }
43857 Py_INCREF(Py_None); resultobj = Py_None;
43858 return resultobj;
43859 fail:
43860 return NULL;
43861 }
43862
43863
43864 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43865 PyObject *resultobj;
43866 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43867 wxWindow *arg2 = (wxWindow *) 0 ;
43868 int arg3 = (int) 0 ;
43869 PyObject * obj0 = 0 ;
43870 PyObject * obj1 = 0 ;
43871 PyObject * obj2 = 0 ;
43872 char *kwnames[] = {
43873 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43874 };
43875
43876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43878 if (SWIG_arg_fail(1)) SWIG_fail;
43879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43880 if (SWIG_arg_fail(2)) SWIG_fail;
43881 if (obj2) {
43882 {
43883 arg3 = (int)(SWIG_As_int(obj2));
43884 if (SWIG_arg_fail(3)) SWIG_fail;
43885 }
43886 }
43887 {
43888 PyThreadState* __tstate = wxPyBeginAllowThreads();
43889 (arg1)->Below(arg2,arg3);
43890
43891 wxPyEndAllowThreads(__tstate);
43892 if (PyErr_Occurred()) SWIG_fail;
43893 }
43894 Py_INCREF(Py_None); resultobj = Py_None;
43895 return resultobj;
43896 fail:
43897 return NULL;
43898 }
43899
43900
43901 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43902 PyObject *resultobj;
43903 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43904 wxWindow *arg2 = (wxWindow *) 0 ;
43905 wxEdge arg3 ;
43906 int arg4 = (int) 0 ;
43907 PyObject * obj0 = 0 ;
43908 PyObject * obj1 = 0 ;
43909 PyObject * obj2 = 0 ;
43910 PyObject * obj3 = 0 ;
43911 char *kwnames[] = {
43912 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43913 };
43914
43915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43917 if (SWIG_arg_fail(1)) SWIG_fail;
43918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43919 if (SWIG_arg_fail(2)) SWIG_fail;
43920 {
43921 arg3 = (wxEdge)(SWIG_As_int(obj2));
43922 if (SWIG_arg_fail(3)) SWIG_fail;
43923 }
43924 if (obj3) {
43925 {
43926 arg4 = (int)(SWIG_As_int(obj3));
43927 if (SWIG_arg_fail(4)) SWIG_fail;
43928 }
43929 }
43930 {
43931 PyThreadState* __tstate = wxPyBeginAllowThreads();
43932 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43933
43934 wxPyEndAllowThreads(__tstate);
43935 if (PyErr_Occurred()) SWIG_fail;
43936 }
43937 Py_INCREF(Py_None); resultobj = Py_None;
43938 return resultobj;
43939 fail:
43940 return NULL;
43941 }
43942
43943
43944 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43945 PyObject *resultobj;
43946 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43947 wxWindow *arg2 = (wxWindow *) 0 ;
43948 wxEdge arg3 ;
43949 int arg4 ;
43950 PyObject * obj0 = 0 ;
43951 PyObject * obj1 = 0 ;
43952 PyObject * obj2 = 0 ;
43953 PyObject * obj3 = 0 ;
43954 char *kwnames[] = {
43955 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43956 };
43957
43958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43960 if (SWIG_arg_fail(1)) SWIG_fail;
43961 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43962 if (SWIG_arg_fail(2)) SWIG_fail;
43963 {
43964 arg3 = (wxEdge)(SWIG_As_int(obj2));
43965 if (SWIG_arg_fail(3)) SWIG_fail;
43966 }
43967 {
43968 arg4 = (int)(SWIG_As_int(obj3));
43969 if (SWIG_arg_fail(4)) SWIG_fail;
43970 }
43971 {
43972 PyThreadState* __tstate = wxPyBeginAllowThreads();
43973 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43974
43975 wxPyEndAllowThreads(__tstate);
43976 if (PyErr_Occurred()) SWIG_fail;
43977 }
43978 Py_INCREF(Py_None); resultobj = Py_None;
43979 return resultobj;
43980 fail:
43981 return NULL;
43982 }
43983
43984
43985 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43986 PyObject *resultobj;
43987 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43988 int arg2 ;
43989 PyObject * obj0 = 0 ;
43990 PyObject * obj1 = 0 ;
43991 char *kwnames[] = {
43992 (char *) "self",(char *) "val", NULL
43993 };
43994
43995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43997 if (SWIG_arg_fail(1)) SWIG_fail;
43998 {
43999 arg2 = (int)(SWIG_As_int(obj1));
44000 if (SWIG_arg_fail(2)) SWIG_fail;
44001 }
44002 {
44003 PyThreadState* __tstate = wxPyBeginAllowThreads();
44004 (arg1)->Absolute(arg2);
44005
44006 wxPyEndAllowThreads(__tstate);
44007 if (PyErr_Occurred()) SWIG_fail;
44008 }
44009 Py_INCREF(Py_None); resultobj = Py_None;
44010 return resultobj;
44011 fail:
44012 return NULL;
44013 }
44014
44015
44016 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44017 PyObject *resultobj;
44018 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44019 PyObject * obj0 = 0 ;
44020 char *kwnames[] = {
44021 (char *) "self", NULL
44022 };
44023
44024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44026 if (SWIG_arg_fail(1)) SWIG_fail;
44027 {
44028 PyThreadState* __tstate = wxPyBeginAllowThreads();
44029 (arg1)->Unconstrained();
44030
44031 wxPyEndAllowThreads(__tstate);
44032 if (PyErr_Occurred()) SWIG_fail;
44033 }
44034 Py_INCREF(Py_None); resultobj = Py_None;
44035 return resultobj;
44036 fail:
44037 return NULL;
44038 }
44039
44040
44041 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44042 PyObject *resultobj;
44043 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44044 PyObject * obj0 = 0 ;
44045 char *kwnames[] = {
44046 (char *) "self", NULL
44047 };
44048
44049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44051 if (SWIG_arg_fail(1)) SWIG_fail;
44052 {
44053 PyThreadState* __tstate = wxPyBeginAllowThreads();
44054 (arg1)->AsIs();
44055
44056 wxPyEndAllowThreads(__tstate);
44057 if (PyErr_Occurred()) SWIG_fail;
44058 }
44059 Py_INCREF(Py_None); resultobj = Py_None;
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44067 PyObject *resultobj;
44068 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44069 wxWindow *result;
44070 PyObject * obj0 = 0 ;
44071 char *kwnames[] = {
44072 (char *) "self", NULL
44073 };
44074
44075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44077 if (SWIG_arg_fail(1)) SWIG_fail;
44078 {
44079 PyThreadState* __tstate = wxPyBeginAllowThreads();
44080 result = (wxWindow *)(arg1)->GetOtherWindow();
44081
44082 wxPyEndAllowThreads(__tstate);
44083 if (PyErr_Occurred()) SWIG_fail;
44084 }
44085 {
44086 resultobj = wxPyMake_wxObject(result, 0);
44087 }
44088 return resultobj;
44089 fail:
44090 return NULL;
44091 }
44092
44093
44094 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44095 PyObject *resultobj;
44096 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44097 wxEdge result;
44098 PyObject * obj0 = 0 ;
44099 char *kwnames[] = {
44100 (char *) "self", NULL
44101 };
44102
44103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44105 if (SWIG_arg_fail(1)) SWIG_fail;
44106 {
44107 PyThreadState* __tstate = wxPyBeginAllowThreads();
44108 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44109
44110 wxPyEndAllowThreads(__tstate);
44111 if (PyErr_Occurred()) SWIG_fail;
44112 }
44113 resultobj = SWIG_From_int((result));
44114 return resultobj;
44115 fail:
44116 return NULL;
44117 }
44118
44119
44120 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44121 PyObject *resultobj;
44122 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44123 wxEdge arg2 ;
44124 PyObject * obj0 = 0 ;
44125 PyObject * obj1 = 0 ;
44126 char *kwnames[] = {
44127 (char *) "self",(char *) "which", NULL
44128 };
44129
44130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44132 if (SWIG_arg_fail(1)) SWIG_fail;
44133 {
44134 arg2 = (wxEdge)(SWIG_As_int(obj1));
44135 if (SWIG_arg_fail(2)) SWIG_fail;
44136 }
44137 {
44138 PyThreadState* __tstate = wxPyBeginAllowThreads();
44139 (arg1)->SetEdge((wxEdge )arg2);
44140
44141 wxPyEndAllowThreads(__tstate);
44142 if (PyErr_Occurred()) SWIG_fail;
44143 }
44144 Py_INCREF(Py_None); resultobj = Py_None;
44145 return resultobj;
44146 fail:
44147 return NULL;
44148 }
44149
44150
44151 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44152 PyObject *resultobj;
44153 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44154 int arg2 ;
44155 PyObject * obj0 = 0 ;
44156 PyObject * obj1 = 0 ;
44157 char *kwnames[] = {
44158 (char *) "self",(char *) "v", NULL
44159 };
44160
44161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44163 if (SWIG_arg_fail(1)) SWIG_fail;
44164 {
44165 arg2 = (int)(SWIG_As_int(obj1));
44166 if (SWIG_arg_fail(2)) SWIG_fail;
44167 }
44168 {
44169 PyThreadState* __tstate = wxPyBeginAllowThreads();
44170 (arg1)->SetValue(arg2);
44171
44172 wxPyEndAllowThreads(__tstate);
44173 if (PyErr_Occurred()) SWIG_fail;
44174 }
44175 Py_INCREF(Py_None); resultobj = Py_None;
44176 return resultobj;
44177 fail:
44178 return NULL;
44179 }
44180
44181
44182 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44183 PyObject *resultobj;
44184 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44185 int result;
44186 PyObject * obj0 = 0 ;
44187 char *kwnames[] = {
44188 (char *) "self", NULL
44189 };
44190
44191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44193 if (SWIG_arg_fail(1)) SWIG_fail;
44194 {
44195 PyThreadState* __tstate = wxPyBeginAllowThreads();
44196 result = (int)(arg1)->GetMargin();
44197
44198 wxPyEndAllowThreads(__tstate);
44199 if (PyErr_Occurred()) SWIG_fail;
44200 }
44201 {
44202 resultobj = SWIG_From_int((int)(result));
44203 }
44204 return resultobj;
44205 fail:
44206 return NULL;
44207 }
44208
44209
44210 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44211 PyObject *resultobj;
44212 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44213 int arg2 ;
44214 PyObject * obj0 = 0 ;
44215 PyObject * obj1 = 0 ;
44216 char *kwnames[] = {
44217 (char *) "self",(char *) "m", NULL
44218 };
44219
44220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44222 if (SWIG_arg_fail(1)) SWIG_fail;
44223 {
44224 arg2 = (int)(SWIG_As_int(obj1));
44225 if (SWIG_arg_fail(2)) SWIG_fail;
44226 }
44227 {
44228 PyThreadState* __tstate = wxPyBeginAllowThreads();
44229 (arg1)->SetMargin(arg2);
44230
44231 wxPyEndAllowThreads(__tstate);
44232 if (PyErr_Occurred()) SWIG_fail;
44233 }
44234 Py_INCREF(Py_None); resultobj = Py_None;
44235 return resultobj;
44236 fail:
44237 return NULL;
44238 }
44239
44240
44241 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44242 PyObject *resultobj;
44243 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44244 int result;
44245 PyObject * obj0 = 0 ;
44246 char *kwnames[] = {
44247 (char *) "self", NULL
44248 };
44249
44250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44252 if (SWIG_arg_fail(1)) SWIG_fail;
44253 {
44254 PyThreadState* __tstate = wxPyBeginAllowThreads();
44255 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44256
44257 wxPyEndAllowThreads(__tstate);
44258 if (PyErr_Occurred()) SWIG_fail;
44259 }
44260 {
44261 resultobj = SWIG_From_int((int)(result));
44262 }
44263 return resultobj;
44264 fail:
44265 return NULL;
44266 }
44267
44268
44269 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44270 PyObject *resultobj;
44271 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44272 int result;
44273 PyObject * obj0 = 0 ;
44274 char *kwnames[] = {
44275 (char *) "self", NULL
44276 };
44277
44278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44280 if (SWIG_arg_fail(1)) SWIG_fail;
44281 {
44282 PyThreadState* __tstate = wxPyBeginAllowThreads();
44283 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44284
44285 wxPyEndAllowThreads(__tstate);
44286 if (PyErr_Occurred()) SWIG_fail;
44287 }
44288 {
44289 resultobj = SWIG_From_int((int)(result));
44290 }
44291 return resultobj;
44292 fail:
44293 return NULL;
44294 }
44295
44296
44297 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44298 PyObject *resultobj;
44299 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44300 int result;
44301 PyObject * obj0 = 0 ;
44302 char *kwnames[] = {
44303 (char *) "self", NULL
44304 };
44305
44306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44308 if (SWIG_arg_fail(1)) SWIG_fail;
44309 {
44310 PyThreadState* __tstate = wxPyBeginAllowThreads();
44311 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44312
44313 wxPyEndAllowThreads(__tstate);
44314 if (PyErr_Occurred()) SWIG_fail;
44315 }
44316 {
44317 resultobj = SWIG_From_int((int)(result));
44318 }
44319 return resultobj;
44320 fail:
44321 return NULL;
44322 }
44323
44324
44325 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44326 PyObject *resultobj;
44327 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44328 bool result;
44329 PyObject * obj0 = 0 ;
44330 char *kwnames[] = {
44331 (char *) "self", NULL
44332 };
44333
44334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44336 if (SWIG_arg_fail(1)) SWIG_fail;
44337 {
44338 PyThreadState* __tstate = wxPyBeginAllowThreads();
44339 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44340
44341 wxPyEndAllowThreads(__tstate);
44342 if (PyErr_Occurred()) SWIG_fail;
44343 }
44344 {
44345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44346 }
44347 return resultobj;
44348 fail:
44349 return NULL;
44350 }
44351
44352
44353 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44354 PyObject *resultobj;
44355 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44356 bool arg2 ;
44357 PyObject * obj0 = 0 ;
44358 PyObject * obj1 = 0 ;
44359 char *kwnames[] = {
44360 (char *) "self",(char *) "d", NULL
44361 };
44362
44363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44365 if (SWIG_arg_fail(1)) SWIG_fail;
44366 {
44367 arg2 = (bool)(SWIG_As_bool(obj1));
44368 if (SWIG_arg_fail(2)) SWIG_fail;
44369 }
44370 {
44371 PyThreadState* __tstate = wxPyBeginAllowThreads();
44372 (arg1)->SetDone(arg2);
44373
44374 wxPyEndAllowThreads(__tstate);
44375 if (PyErr_Occurred()) SWIG_fail;
44376 }
44377 Py_INCREF(Py_None); resultobj = Py_None;
44378 return resultobj;
44379 fail:
44380 return NULL;
44381 }
44382
44383
44384 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44385 PyObject *resultobj;
44386 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44387 wxRelationship result;
44388 PyObject * obj0 = 0 ;
44389 char *kwnames[] = {
44390 (char *) "self", NULL
44391 };
44392
44393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44395 if (SWIG_arg_fail(1)) SWIG_fail;
44396 {
44397 PyThreadState* __tstate = wxPyBeginAllowThreads();
44398 result = (wxRelationship)(arg1)->GetRelationship();
44399
44400 wxPyEndAllowThreads(__tstate);
44401 if (PyErr_Occurred()) SWIG_fail;
44402 }
44403 resultobj = SWIG_From_int((result));
44404 return resultobj;
44405 fail:
44406 return NULL;
44407 }
44408
44409
44410 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44411 PyObject *resultobj;
44412 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44413 wxRelationship arg2 ;
44414 PyObject * obj0 = 0 ;
44415 PyObject * obj1 = 0 ;
44416 char *kwnames[] = {
44417 (char *) "self",(char *) "r", NULL
44418 };
44419
44420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44422 if (SWIG_arg_fail(1)) SWIG_fail;
44423 {
44424 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44425 if (SWIG_arg_fail(2)) SWIG_fail;
44426 }
44427 {
44428 PyThreadState* __tstate = wxPyBeginAllowThreads();
44429 (arg1)->SetRelationship((wxRelationship )arg2);
44430
44431 wxPyEndAllowThreads(__tstate);
44432 if (PyErr_Occurred()) SWIG_fail;
44433 }
44434 Py_INCREF(Py_None); resultobj = Py_None;
44435 return resultobj;
44436 fail:
44437 return NULL;
44438 }
44439
44440
44441 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44442 PyObject *resultobj;
44443 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44444 wxWindow *arg2 = (wxWindow *) 0 ;
44445 bool result;
44446 PyObject * obj0 = 0 ;
44447 PyObject * obj1 = 0 ;
44448 char *kwnames[] = {
44449 (char *) "self",(char *) "otherW", NULL
44450 };
44451
44452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44454 if (SWIG_arg_fail(1)) SWIG_fail;
44455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44456 if (SWIG_arg_fail(2)) SWIG_fail;
44457 {
44458 PyThreadState* __tstate = wxPyBeginAllowThreads();
44459 result = (bool)(arg1)->ResetIfWin(arg2);
44460
44461 wxPyEndAllowThreads(__tstate);
44462 if (PyErr_Occurred()) SWIG_fail;
44463 }
44464 {
44465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44466 }
44467 return resultobj;
44468 fail:
44469 return NULL;
44470 }
44471
44472
44473 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44474 PyObject *resultobj;
44475 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44476 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44477 wxWindow *arg3 = (wxWindow *) 0 ;
44478 bool result;
44479 PyObject * obj0 = 0 ;
44480 PyObject * obj1 = 0 ;
44481 PyObject * obj2 = 0 ;
44482 char *kwnames[] = {
44483 (char *) "self",(char *) "constraints",(char *) "win", NULL
44484 };
44485
44486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44488 if (SWIG_arg_fail(1)) SWIG_fail;
44489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44490 if (SWIG_arg_fail(2)) SWIG_fail;
44491 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44492 if (SWIG_arg_fail(3)) SWIG_fail;
44493 {
44494 PyThreadState* __tstate = wxPyBeginAllowThreads();
44495 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44496
44497 wxPyEndAllowThreads(__tstate);
44498 if (PyErr_Occurred()) SWIG_fail;
44499 }
44500 {
44501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44502 }
44503 return resultobj;
44504 fail:
44505 return NULL;
44506 }
44507
44508
44509 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44510 PyObject *resultobj;
44511 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44512 wxEdge arg2 ;
44513 wxWindow *arg3 = (wxWindow *) 0 ;
44514 wxWindow *arg4 = (wxWindow *) 0 ;
44515 int result;
44516 PyObject * obj0 = 0 ;
44517 PyObject * obj1 = 0 ;
44518 PyObject * obj2 = 0 ;
44519 PyObject * obj3 = 0 ;
44520 char *kwnames[] = {
44521 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44522 };
44523
44524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44526 if (SWIG_arg_fail(1)) SWIG_fail;
44527 {
44528 arg2 = (wxEdge)(SWIG_As_int(obj1));
44529 if (SWIG_arg_fail(2)) SWIG_fail;
44530 }
44531 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44532 if (SWIG_arg_fail(3)) SWIG_fail;
44533 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44534 if (SWIG_arg_fail(4)) SWIG_fail;
44535 {
44536 PyThreadState* __tstate = wxPyBeginAllowThreads();
44537 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44538
44539 wxPyEndAllowThreads(__tstate);
44540 if (PyErr_Occurred()) SWIG_fail;
44541 }
44542 {
44543 resultobj = SWIG_From_int((int)(result));
44544 }
44545 return resultobj;
44546 fail:
44547 return NULL;
44548 }
44549
44550
44551 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44552 PyObject *obj;
44553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44554 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44555 Py_INCREF(obj);
44556 return Py_BuildValue((char *)"");
44557 }
44558 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44559 PyObject *resultobj;
44560 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44561 wxIndividualLayoutConstraint *result;
44562 PyObject * obj0 = 0 ;
44563 char *kwnames[] = {
44564 (char *) "self", NULL
44565 };
44566
44567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44569 if (SWIG_arg_fail(1)) SWIG_fail;
44570 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44571
44572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44573 return resultobj;
44574 fail:
44575 return NULL;
44576 }
44577
44578
44579 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44580 PyObject *resultobj;
44581 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44582 wxIndividualLayoutConstraint *result;
44583 PyObject * obj0 = 0 ;
44584 char *kwnames[] = {
44585 (char *) "self", NULL
44586 };
44587
44588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44590 if (SWIG_arg_fail(1)) SWIG_fail;
44591 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44592
44593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44594 return resultobj;
44595 fail:
44596 return NULL;
44597 }
44598
44599
44600 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44601 PyObject *resultobj;
44602 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44603 wxIndividualLayoutConstraint *result;
44604 PyObject * obj0 = 0 ;
44605 char *kwnames[] = {
44606 (char *) "self", NULL
44607 };
44608
44609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44611 if (SWIG_arg_fail(1)) SWIG_fail;
44612 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44613
44614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44615 return resultobj;
44616 fail:
44617 return NULL;
44618 }
44619
44620
44621 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44622 PyObject *resultobj;
44623 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44624 wxIndividualLayoutConstraint *result;
44625 PyObject * obj0 = 0 ;
44626 char *kwnames[] = {
44627 (char *) "self", NULL
44628 };
44629
44630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44632 if (SWIG_arg_fail(1)) SWIG_fail;
44633 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44634
44635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44636 return resultobj;
44637 fail:
44638 return NULL;
44639 }
44640
44641
44642 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44643 PyObject *resultobj;
44644 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44645 wxIndividualLayoutConstraint *result;
44646 PyObject * obj0 = 0 ;
44647 char *kwnames[] = {
44648 (char *) "self", NULL
44649 };
44650
44651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44653 if (SWIG_arg_fail(1)) SWIG_fail;
44654 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44655
44656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44657 return resultobj;
44658 fail:
44659 return NULL;
44660 }
44661
44662
44663 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44664 PyObject *resultobj;
44665 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44666 wxIndividualLayoutConstraint *result;
44667 PyObject * obj0 = 0 ;
44668 char *kwnames[] = {
44669 (char *) "self", NULL
44670 };
44671
44672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44674 if (SWIG_arg_fail(1)) SWIG_fail;
44675 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44676
44677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44678 return resultobj;
44679 fail:
44680 return NULL;
44681 }
44682
44683
44684 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44685 PyObject *resultobj;
44686 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44687 wxIndividualLayoutConstraint *result;
44688 PyObject * obj0 = 0 ;
44689 char *kwnames[] = {
44690 (char *) "self", NULL
44691 };
44692
44693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44695 if (SWIG_arg_fail(1)) SWIG_fail;
44696 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44697
44698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44699 return resultobj;
44700 fail:
44701 return NULL;
44702 }
44703
44704
44705 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44706 PyObject *resultobj;
44707 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44708 wxIndividualLayoutConstraint *result;
44709 PyObject * obj0 = 0 ;
44710 char *kwnames[] = {
44711 (char *) "self", NULL
44712 };
44713
44714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44716 if (SWIG_arg_fail(1)) SWIG_fail;
44717 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44718
44719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44720 return resultobj;
44721 fail:
44722 return NULL;
44723 }
44724
44725
44726 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44727 PyObject *resultobj;
44728 wxLayoutConstraints *result;
44729 char *kwnames[] = {
44730 NULL
44731 };
44732
44733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44734 {
44735 PyThreadState* __tstate = wxPyBeginAllowThreads();
44736 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44737
44738 wxPyEndAllowThreads(__tstate);
44739 if (PyErr_Occurred()) SWIG_fail;
44740 }
44741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44742 return resultobj;
44743 fail:
44744 return NULL;
44745 }
44746
44747
44748 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44749 PyObject *resultobj;
44750 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44751 wxWindow *arg2 = (wxWindow *) 0 ;
44752 int *arg3 = (int *) 0 ;
44753 bool result;
44754 int temp3 ;
44755 int res3 = 0 ;
44756 PyObject * obj0 = 0 ;
44757 PyObject * obj1 = 0 ;
44758 char *kwnames[] = {
44759 (char *) "self",(char *) "win", NULL
44760 };
44761
44762 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44765 if (SWIG_arg_fail(1)) SWIG_fail;
44766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44767 if (SWIG_arg_fail(2)) SWIG_fail;
44768 {
44769 PyThreadState* __tstate = wxPyBeginAllowThreads();
44770 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44771
44772 wxPyEndAllowThreads(__tstate);
44773 if (PyErr_Occurred()) SWIG_fail;
44774 }
44775 {
44776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44777 }
44778 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44779 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44780 return resultobj;
44781 fail:
44782 return NULL;
44783 }
44784
44785
44786 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44787 PyObject *resultobj;
44788 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44789 bool result;
44790 PyObject * obj0 = 0 ;
44791 char *kwnames[] = {
44792 (char *) "self", NULL
44793 };
44794
44795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44797 if (SWIG_arg_fail(1)) SWIG_fail;
44798 {
44799 PyThreadState* __tstate = wxPyBeginAllowThreads();
44800 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44801
44802 wxPyEndAllowThreads(__tstate);
44803 if (PyErr_Occurred()) SWIG_fail;
44804 }
44805 {
44806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44807 }
44808 return resultobj;
44809 fail:
44810 return NULL;
44811 }
44812
44813
44814 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44815 PyObject *obj;
44816 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44817 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44818 Py_INCREF(obj);
44819 return Py_BuildValue((char *)"");
44820 }
44821 static PyMethodDef SwigMethods[] = {
44822 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44823 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44824 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44827 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44848 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44861 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44876 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44929 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44957 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44976 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44978 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44986 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44987 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44999 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45011 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45015 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45021 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45031 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45041 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45045 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45120 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45122 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45124 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45126 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45128 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45130 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45132 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45134 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45136 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45138 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45140 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45142 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45144 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45158 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45176 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45179 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45182 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45194 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45199 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45205 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45211 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45274 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45281 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45317 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45327 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45333 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45335 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45337 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45340 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45344 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45347 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45350 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45352 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45357 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45365 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45369 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45372 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45374 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45378 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45395 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45397 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45400 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45402 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45406 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45410 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45421 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45424 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45427 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45431 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45438 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45443 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45448 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45452 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45497 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45517 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45524 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45528 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45538 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45708 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45750 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45764 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45767 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45822 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45849 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45893 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45901 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45920 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45921 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45958 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45988 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45991 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45995 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45998 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46008 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46020 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46032 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46042 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46052 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46066 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46073 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46074 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46075 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46076 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46077 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46082 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46109 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46121 { NULL, NULL, 0, NULL }
46122 };
46123
46124
46125 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46126
46127 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46128 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46129 }
46130 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46131 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46132 }
46133 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46134 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46135 }
46136 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46137 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46138 }
46139 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46140 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46141 }
46142 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46143 return (void *)((wxSizer *) ((wxGridSizer *) x));
46144 }
46145 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46146 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46147 }
46148 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46149 return (void *)((wxSizer *) ((wxPySizer *) x));
46150 }
46151 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46152 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46153 }
46154 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46155 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46156 }
46157 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46158 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46159 }
46160 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46161 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46162 }
46163 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46164 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46165 }
46166 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46167 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46168 }
46169 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46170 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46171 }
46172 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46173 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46174 }
46175 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46176 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46177 }
46178 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46179 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46180 }
46181 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46182 return (void *)((wxEvent *) ((wxPyEvent *) x));
46183 }
46184 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46185 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46186 }
46187 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46188 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46189 }
46190 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46191 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46192 }
46193 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46194 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46195 }
46196 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46197 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46198 }
46199 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46200 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46201 }
46202 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46203 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46204 }
46205 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46206 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46207 }
46208 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46209 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46210 }
46211 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46212 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46213 }
46214 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46215 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46216 }
46217 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46218 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46219 }
46220 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46221 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46222 }
46223 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46224 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46225 }
46226 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46227 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46228 }
46229 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46230 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46231 }
46232 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46233 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46234 }
46235 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46236 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46237 }
46238 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46239 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46240 }
46241 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46242 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46243 }
46244 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46245 return (void *)((wxEvent *) ((wxShowEvent *) x));
46246 }
46247 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46248 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46249 }
46250 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46251 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46252 }
46253 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46254 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46255 }
46256 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46257 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46258 }
46259 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46260 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46261 }
46262 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46263 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46264 }
46265 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46266 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46267 }
46268 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46269 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46270 }
46271 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46272 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46273 }
46274 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46275 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46276 }
46277 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46278 return (void *)((wxControl *) ((wxControlWithItems *) x));
46279 }
46280 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46281 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46282 }
46283 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46284 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46285 }
46286 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46287 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46288 }
46289 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46290 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46291 }
46292 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46293 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46294 }
46295 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46296 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46297 }
46298 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46299 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46300 }
46301 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46302 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46303 }
46304 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46305 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46306 }
46307 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46308 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46309 }
46310 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46311 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46312 }
46313 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46314 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46315 }
46316 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46317 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46318 }
46319 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46320 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46321 }
46322 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46323 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46324 }
46325 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46326 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46327 }
46328 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46329 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46330 }
46331 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46332 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46333 }
46334 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46335 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46336 }
46337 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46338 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46339 }
46340 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46341 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46342 }
46343 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46344 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46345 }
46346 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46347 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46348 }
46349 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46350 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46351 }
46352 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46353 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46354 }
46355 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46356 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46357 }
46358 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46359 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46360 }
46361 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46362 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46363 }
46364 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46365 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46366 }
46367 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46368 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46369 }
46370 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46371 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46372 }
46373 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46374 return (void *)((wxObject *) ((wxSizerItem *) x));
46375 }
46376 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46377 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46378 }
46379 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46380 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46381 }
46382 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46383 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46384 }
46385 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46386 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46387 }
46388 static void *_p_wxSizerTo_p_wxObject(void *x) {
46389 return (void *)((wxObject *) ((wxSizer *) x));
46390 }
46391 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46392 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46393 }
46394 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46395 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46396 }
46397 static void *_p_wxEventTo_p_wxObject(void *x) {
46398 return (void *)((wxObject *) ((wxEvent *) x));
46399 }
46400 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46401 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46402 }
46403 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46404 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46405 }
46406 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46407 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46408 }
46409 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46410 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46411 }
46412 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46413 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46414 }
46415 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46416 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46417 }
46418 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46419 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46420 }
46421 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46422 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46423 }
46424 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46425 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46426 }
46427 static void *_p_wxControlTo_p_wxObject(void *x) {
46428 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46429 }
46430 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46431 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46432 }
46433 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46434 return (void *)((wxObject *) ((wxFSFile *) x));
46435 }
46436 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46437 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46438 }
46439 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46440 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46441 }
46442 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46443 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46444 }
46445 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46446 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46447 }
46448 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46449 return (void *)((wxObject *) ((wxMenuItem *) x));
46450 }
46451 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46452 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46453 }
46454 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46455 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46456 }
46457 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46458 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46459 }
46460 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46461 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46462 }
46463 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46464 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46465 }
46466 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46467 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46468 }
46469 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46470 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46471 }
46472 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46473 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46474 }
46475 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46476 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46477 }
46478 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46479 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46480 }
46481 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46482 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46483 }
46484 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46485 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46486 }
46487 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46488 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46489 }
46490 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46491 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46492 }
46493 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46494 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46495 }
46496 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46497 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46498 }
46499 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46500 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46501 }
46502 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46503 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46504 }
46505 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46506 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46507 }
46508 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46509 return (void *)((wxObject *) ((wxImageHandler *) x));
46510 }
46511 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46512 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46513 }
46514 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46515 return (void *)((wxObject *) ((wxEvtHandler *) x));
46516 }
46517 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46518 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46519 }
46520 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46521 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46522 }
46523 static void *_p_wxImageTo_p_wxObject(void *x) {
46524 return (void *)((wxObject *) ((wxImage *) x));
46525 }
46526 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46527 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46528 }
46529 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46530 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46531 }
46532 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46533 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46534 }
46535 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46536 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46537 }
46538 static void *_p_wxWindowTo_p_wxObject(void *x) {
46539 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46540 }
46541 static void *_p_wxMenuTo_p_wxObject(void *x) {
46542 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46543 }
46544 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46545 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46546 }
46547 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46548 return (void *)((wxObject *) ((wxFileSystem *) x));
46549 }
46550 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46551 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46552 }
46553 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46554 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46555 }
46556 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46557 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46558 }
46559 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46560 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46561 }
46562 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46563 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46564 }
46565 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46566 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46567 }
46568 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46569 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46570 }
46571 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46572 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46573 }
46574 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46575 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46576 }
46577 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46578 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46579 }
46580 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46581 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46582 }
46583 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46584 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46585 }
46586 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46587 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46588 }
46589 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46590 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46591 }
46592 static void *_p_wxControlTo_p_wxWindow(void *x) {
46593 return (void *)((wxWindow *) ((wxControl *) x));
46594 }
46595 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46596 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46597 }
46598 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46599 return (void *)((wxWindow *) ((wxMenuBar *) x));
46600 }
46601 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46602 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46603 }
46604 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46605 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46606 }
46607 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46608 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46609 }
46610 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46611 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46612 }
46613 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46614 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46615 }
46616 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46617 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46618 }
46619 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46620 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46621 }
46622 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46623 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46624 }
46625 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46626 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46627 }
46628 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46629 return (void *)((wxValidator *) ((wxPyValidator *) x));
46630 }
46631 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}};
46632 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}};
46633 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}};
46634 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}};
46635 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}};
46636 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}};
46637 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}};
46638 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}};
46639 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}};
46640 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}};
46641 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}};
46642 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}};
46643 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}};
46644 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46645 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}};
46646 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}};
46647 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}};
46648 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}};
46649 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}};
46650 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}};
46651 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}};
46652 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}};
46653 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}};
46654 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}};
46655 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}};
46656 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}};
46657 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}};
46658 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}};
46659 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}};
46660 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}};
46661 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}};
46662 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}};
46663 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}};
46664 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}};
46665 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}};
46666 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}};
46667 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}};
46668 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}};
46669 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}};
46670 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}};
46671 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}};
46672 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}};
46673 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}};
46674 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}};
46675 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}};
46676 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}};
46677 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}};
46678 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}};
46679 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}};
46680 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}};
46681 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}};
46682 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}};
46683 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}};
46684 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}};
46685 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}};
46686 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}};
46687 static swig_type_info _swigt__p_wxDateEvent[] = {{"_p_wxDateEvent", 0, "wxDateEvent *", 0, 0, 0, 0},{"_p_wxDateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46688 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}};
46689 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}};
46690 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}};
46691 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}};
46692 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}};
46693 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}};
46694 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}};
46695 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}};
46696 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}};
46697 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}};
46698 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}};
46699 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}};
46700 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}};
46701 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}};
46702 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}};
46703 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}};
46704 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}};
46705 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}};
46706 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}};
46707 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}};
46708 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}};
46709 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}};
46710 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}};
46711 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}};
46712 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}};
46713 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}};
46714 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}};
46715 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}};
46716 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}};
46717 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}};
46718 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}};
46719 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}};
46720 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}};
46721 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}};
46722 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}};
46723 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}};
46724 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}};
46725 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46726 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}};
46727 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}};
46728 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}};
46729 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}};
46730 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}};
46731 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}};
46732 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}};
46733 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}};
46734 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}};
46735 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}};
46736 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}};
46737 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}};
46738 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}};
46739 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}};
46740 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}};
46741 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}};
46742 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}};
46743 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}};
46744 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}};
46745 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}};
46746 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}};
46747 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46748 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}};
46749 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}};
46750 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}};
46751 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}};
46752 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}};
46753 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}};
46754 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}};
46755 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}};
46756 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}};
46757 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}};
46758
46759 static swig_type_info *swig_types_initial[] = {
46760 _swigt__p_wxLayoutConstraints,
46761 _swigt__p_wxRealPoint,
46762 _swigt__p_wxSizerItem,
46763 _swigt__p_wxGBSizerItem,
46764 _swigt__p_wxScrollEvent,
46765 _swigt__p_wxEventLoop,
46766 _swigt__p_wxIndividualLayoutConstraint,
46767 _swigt__p_wxSizer,
46768 _swigt__p_wxBoxSizer,
46769 _swigt__p_wxStaticBoxSizer,
46770 _swigt__p_wxGridBagSizer,
46771 _swigt__p_wxAcceleratorEntry,
46772 _swigt__p_wxUpdateUIEvent,
46773 _swigt__p_wxEvent,
46774 _swigt__p_wxMenu,
46775 _swigt__p_wxGridSizer,
46776 _swigt__p_wxFlexGridSizer,
46777 _swigt__p_wxInitDialogEvent,
46778 _swigt__p_wxItemContainer,
46779 _swigt__p_wxNcPaintEvent,
46780 _swigt__p_wxPaintEvent,
46781 _swigt__p_wxSysColourChangedEvent,
46782 _swigt__p_wxMouseCaptureChangedEvent,
46783 _swigt__p_wxDisplayChangedEvent,
46784 _swigt__p_wxPaletteChangedEvent,
46785 _swigt__p_wxControl,
46786 _swigt__p_wxFont,
46787 _swigt__p_wxMenuBarBase,
46788 _swigt__p_wxSetCursorEvent,
46789 _swigt__p_wxFSFile,
46790 _swigt__p_wxCaret,
46791 _swigt__ptrdiff_t,
46792 _swigt__std__ptrdiff_t,
46793 _swigt__p_wxRegion,
46794 _swigt__p_wxPoint2D,
46795 _swigt__p_int,
46796 _swigt__p_wxSize,
46797 _swigt__p_wxDC,
46798 _swigt__p_wxPySizer,
46799 _swigt__p_wxVisualAttributes,
46800 _swigt__p_wxNotifyEvent,
46801 _swigt__p_wxPyEvent,
46802 _swigt__p_wxPropagationDisabler,
46803 _swigt__p_form_ops_t,
46804 _swigt__p_wxAppTraits,
46805 _swigt__p_wxArrayString,
46806 _swigt__p_wxShowEvent,
46807 _swigt__p_wxToolTip,
46808 _swigt__p_wxMoveEvent,
46809 _swigt__p_wxSizeEvent,
46810 _swigt__p_wxActivateEvent,
46811 _swigt__p_wxIconizeEvent,
46812 _swigt__p_wxMaximizeEvent,
46813 _swigt__p_wxQueryNewPaletteEvent,
46814 _swigt__p_wxWindowCreateEvent,
46815 _swigt__p_wxIdleEvent,
46816 _swigt__p_wxDateEvent,
46817 _swigt__p_wxMenuItem,
46818 _swigt__p_wxStaticBox,
46819 _swigt__p_long,
46820 _swigt__p_wxDuplexMode,
46821 _swigt__p_wxTIFFHandler,
46822 _swigt__p_wxXPMHandler,
46823 _swigt__p_wxPNMHandler,
46824 _swigt__p_wxJPEGHandler,
46825 _swigt__p_wxPCXHandler,
46826 _swigt__p_wxGIFHandler,
46827 _swigt__p_wxPNGHandler,
46828 _swigt__p_wxANIHandler,
46829 _swigt__p_wxMemoryFSHandler,
46830 _swigt__p_wxZipFSHandler,
46831 _swigt__p_wxInternetFSHandler,
46832 _swigt__p_wxPyFileSystemHandler,
46833 _swigt__p_wxEvtHandler,
46834 _swigt__p_wxCURHandler,
46835 _swigt__p_wxICOHandler,
46836 _swigt__p_wxBMPHandler,
46837 _swigt__p_wxImageHandler,
46838 _swigt__p_wxFileSystemHandler,
46839 _swigt__p_wxRect,
46840 _swigt__p_wxButton,
46841 _swigt__p_wxGBSpan,
46842 _swigt__p_wxPropagateOnce,
46843 _swigt__p_wxAcceleratorTable,
46844 _swigt__p_wxStdDialogButtonSizer,
46845 _swigt__p_char,
46846 _swigt__p_wxGBPosition,
46847 _swigt__p_wxImage,
46848 _swigt__p_wxFrame,
46849 _swigt__p_wxScrollWinEvent,
46850 _swigt__p_wxPaperSize,
46851 _swigt__p_wxImageHistogram,
46852 _swigt__p_wxPoint,
46853 _swigt__p_wxCursor,
46854 _swigt__p_wxObject,
46855 _swigt__p_wxInputStream,
46856 _swigt__p_wxOutputStream,
46857 _swigt__p_wxPyInputStream,
46858 _swigt__p_wxDateTime,
46859 _swigt__p_wxKeyEvent,
46860 _swigt__p_wxNavigationKeyEvent,
46861 _swigt__p_wxWindowDestroyEvent,
46862 _swigt__p_unsigned_long,
46863 _swigt__p_wxWindow,
46864 _swigt__p_wxMenuBar,
46865 _swigt__p_wxFileSystem,
46866 _swigt__p_wxBitmap,
46867 _swigt__unsigned_int,
46868 _swigt__p_unsigned_int,
46869 _swigt__p_wxMenuEvent,
46870 _swigt__p_wxContextMenuEvent,
46871 _swigt__p_unsigned_char,
46872 _swigt__p_wxEraseEvent,
46873 _swigt__p_wxMouseEvent,
46874 _swigt__p_wxCloseEvent,
46875 _swigt__p_wxPyApp,
46876 _swigt__p_wxCommandEvent,
46877 _swigt__p_wxPyCommandEvent,
46878 _swigt__p_wxPyDropTarget,
46879 _swigt__p_wxQuantize,
46880 _swigt__p_wxChildFocusEvent,
46881 _swigt__p_wxFocusEvent,
46882 _swigt__p_wxDropFilesEvent,
46883 _swigt__p_wxControlWithItems,
46884 _swigt__p_wxColour,
46885 _swigt__p_wxValidator,
46886 _swigt__p_wxPyValidator,
46887 0
46888 };
46889
46890
46891 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46892
46893 static swig_const_info swig_const_table[] = {
46894 {0, 0, 0, 0.0, 0, 0}};
46895
46896 #ifdef __cplusplus
46897 }
46898 #endif
46899
46900
46901 #ifdef __cplusplus
46902 extern "C" {
46903 #endif
46904
46905 /* Python-specific SWIG API */
46906 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46907 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46908 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46909
46910 /* -----------------------------------------------------------------------------
46911 * global variable support code.
46912 * ----------------------------------------------------------------------------- */
46913
46914 typedef struct swig_globalvar {
46915 char *name; /* Name of global variable */
46916 PyObject *(*get_attr)(); /* Return the current value */
46917 int (*set_attr)(PyObject *); /* Set the value */
46918 struct swig_globalvar *next;
46919 } swig_globalvar;
46920
46921 typedef struct swig_varlinkobject {
46922 PyObject_HEAD
46923 swig_globalvar *vars;
46924 } swig_varlinkobject;
46925
46926 static PyObject *
46927 swig_varlink_repr(swig_varlinkobject *v) {
46928 v = v;
46929 return PyString_FromString("<Swig global variables>");
46930 }
46931
46932 static int
46933 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46934 swig_globalvar *var;
46935 flags = flags;
46936 fprintf(fp,"Swig global variables { ");
46937 for (var = v->vars; var; var=var->next) {
46938 fprintf(fp,"%s", var->name);
46939 if (var->next) fprintf(fp,", ");
46940 }
46941 fprintf(fp," }\n");
46942 return 0;
46943 }
46944
46945 static PyObject *
46946 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46947 swig_globalvar *var = v->vars;
46948 while (var) {
46949 if (strcmp(var->name,n) == 0) {
46950 return (*var->get_attr)();
46951 }
46952 var = var->next;
46953 }
46954 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46955 return NULL;
46956 }
46957
46958 static int
46959 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46960 swig_globalvar *var = v->vars;
46961 while (var) {
46962 if (strcmp(var->name,n) == 0) {
46963 return (*var->set_attr)(p);
46964 }
46965 var = var->next;
46966 }
46967 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46968 return 1;
46969 }
46970
46971 static PyTypeObject varlinktype = {
46972 PyObject_HEAD_INIT(0)
46973 0, /* Number of items in variable part (ob_size) */
46974 (char *)"swigvarlink", /* Type name (tp_name) */
46975 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46976 0, /* Itemsize (tp_itemsize) */
46977 0, /* Deallocator (tp_dealloc) */
46978 (printfunc) swig_varlink_print, /* Print (tp_print) */
46979 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46980 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46981 0, /* tp_compare */
46982 (reprfunc) swig_varlink_repr, /* tp_repr */
46983 0, /* tp_as_number */
46984 0, /* tp_as_sequence */
46985 0, /* tp_as_mapping */
46986 0, /* tp_hash */
46987 0, /* tp_call */
46988 0, /* tp_str */
46989 0, /* tp_getattro */
46990 0, /* tp_setattro */
46991 0, /* tp_as_buffer */
46992 0, /* tp_flags */
46993 0, /* tp_doc */
46994 #if PY_VERSION_HEX >= 0x02000000
46995 0, /* tp_traverse */
46996 0, /* tp_clear */
46997 #endif
46998 #if PY_VERSION_HEX >= 0x02010000
46999 0, /* tp_richcompare */
47000 0, /* tp_weaklistoffset */
47001 #endif
47002 #if PY_VERSION_HEX >= 0x02020000
47003 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47004 #endif
47005 #if PY_VERSION_HEX >= 0x02030000
47006 0, /* tp_del */
47007 #endif
47008 #ifdef COUNT_ALLOCS
47009 0,0,0,0 /* tp_alloc -> tp_next */
47010 #endif
47011 };
47012
47013 /* Create a variable linking object for use later */
47014 static PyObject *
47015 SWIG_Python_newvarlink(void) {
47016 swig_varlinkobject *result = 0;
47017 result = PyMem_NEW(swig_varlinkobject,1);
47018 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47019 result->ob_type = &varlinktype;
47020 result->vars = 0;
47021 result->ob_refcnt = 0;
47022 Py_XINCREF((PyObject *) result);
47023 return ((PyObject*) result);
47024 }
47025
47026 static void
47027 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47028 swig_varlinkobject *v;
47029 swig_globalvar *gv;
47030 v= (swig_varlinkobject *) p;
47031 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47032 gv->name = (char *) malloc(strlen(name)+1);
47033 strcpy(gv->name,name);
47034 gv->get_attr = get_attr;
47035 gv->set_attr = set_attr;
47036 gv->next = v->vars;
47037 v->vars = gv;
47038 }
47039
47040 /* -----------------------------------------------------------------------------
47041 * constants/methods manipulation
47042 * ----------------------------------------------------------------------------- */
47043
47044 /* Install Constants */
47045 static void
47046 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47047 PyObject *obj = 0;
47048 size_t i;
47049 for (i = 0; constants[i].type; i++) {
47050 switch(constants[i].type) {
47051 case SWIG_PY_INT:
47052 obj = PyInt_FromLong(constants[i].lvalue);
47053 break;
47054 case SWIG_PY_FLOAT:
47055 obj = PyFloat_FromDouble(constants[i].dvalue);
47056 break;
47057 case SWIG_PY_STRING:
47058 if (constants[i].pvalue) {
47059 obj = PyString_FromString((char *) constants[i].pvalue);
47060 } else {
47061 Py_INCREF(Py_None);
47062 obj = Py_None;
47063 }
47064 break;
47065 case SWIG_PY_POINTER:
47066 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47067 break;
47068 case SWIG_PY_BINARY:
47069 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47070 break;
47071 default:
47072 obj = 0;
47073 break;
47074 }
47075 if (obj) {
47076 PyDict_SetItemString(d,constants[i].name,obj);
47077 Py_DECREF(obj);
47078 }
47079 }
47080 }
47081
47082 /* -----------------------------------------------------------------------------*/
47083 /* Fix SwigMethods to carry the callback ptrs when needed */
47084 /* -----------------------------------------------------------------------------*/
47085
47086 static void
47087 SWIG_Python_FixMethods(PyMethodDef *methods,
47088 swig_const_info *const_table,
47089 swig_type_info **types,
47090 swig_type_info **types_initial) {
47091 size_t i;
47092 for (i = 0; methods[i].ml_name; ++i) {
47093 char *c = methods[i].ml_doc;
47094 if (c && (c = strstr(c, "swig_ptr: "))) {
47095 int j;
47096 swig_const_info *ci = 0;
47097 char *name = c + 10;
47098 for (j = 0; const_table[j].type; j++) {
47099 if (strncmp(const_table[j].name, name,
47100 strlen(const_table[j].name)) == 0) {
47101 ci = &(const_table[j]);
47102 break;
47103 }
47104 }
47105 if (ci) {
47106 size_t shift = (ci->ptype) - types;
47107 swig_type_info *ty = types_initial[shift];
47108 size_t ldoc = (c - methods[i].ml_doc);
47109 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47110 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47111 char *buff = ndoc;
47112 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47113 strncpy(buff, methods[i].ml_doc, ldoc);
47114 buff += ldoc;
47115 strncpy(buff, "swig_ptr: ", 10);
47116 buff += 10;
47117 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47118 methods[i].ml_doc = ndoc;
47119 }
47120 }
47121 }
47122 }
47123
47124 /* -----------------------------------------------------------------------------*
47125 * Initialize type list
47126 * -----------------------------------------------------------------------------*/
47127
47128 #if PY_MAJOR_VERSION < 2
47129 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47130 is copied out of Python/modsupport.c in python version 2.3.4 */
47131 static int
47132 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47133 {
47134 PyObject *dict;
47135 if (!PyModule_Check(m)) {
47136 PyErr_SetString(PyExc_TypeError,
47137 "PyModule_AddObject() needs module as first arg");
47138 return -1;
47139 }
47140 if (!o) {
47141 PyErr_SetString(PyExc_TypeError,
47142 "PyModule_AddObject() needs non-NULL value");
47143 return -1;
47144 }
47145
47146 dict = PyModule_GetDict(m);
47147 if (dict == NULL) {
47148 /* Internal error -- modules must have a dict! */
47149 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47150 PyModule_GetName(m));
47151 return -1;
47152 }
47153 if (PyDict_SetItemString(dict, name, o))
47154 return -1;
47155 Py_DECREF(o);
47156 return 0;
47157 }
47158 #endif
47159
47160 static swig_type_info **
47161 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47162 static PyMethodDef swig_empty_runtime_method_table[] = {
47163 {
47164 NULL, NULL, 0, NULL
47165 }
47166 };/* Sentinel */
47167
47168 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47169 swig_empty_runtime_method_table);
47170 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47171 if (pointer && module) {
47172 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47173 }
47174 return type_list_handle;
47175 }
47176
47177 static swig_type_info **
47178 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47179 swig_type_info **type_pointer;
47180
47181 /* first check if module already created */
47182 type_pointer = SWIG_Python_GetTypeListHandle();
47183 if (type_pointer) {
47184 return type_pointer;
47185 } else {
47186 /* create a new module and variable */
47187 return SWIG_Python_SetTypeListHandle(type_list_handle);
47188 }
47189 }
47190
47191 #ifdef __cplusplus
47192 }
47193 #endif
47194
47195 /* -----------------------------------------------------------------------------*
47196 * Partial Init method
47197 * -----------------------------------------------------------------------------*/
47198
47199 #ifdef SWIG_LINK_RUNTIME
47200 #ifdef __cplusplus
47201 extern "C"
47202 #endif
47203 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47204 #endif
47205
47206 #ifdef __cplusplus
47207 extern "C"
47208 #endif
47209 SWIGEXPORT(void) SWIG_init(void) {
47210 static PyObject *SWIG_globals = 0;
47211 static int typeinit = 0;
47212 PyObject *m, *d;
47213 int i;
47214 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47215
47216 /* Fix SwigMethods to carry the callback ptrs when needed */
47217 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47218
47219 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47220 d = PyModule_GetDict(m);
47221
47222 if (!typeinit) {
47223 #ifdef SWIG_LINK_RUNTIME
47224 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47225 #else
47226 # ifndef SWIG_STATIC_RUNTIME
47227 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47228 # endif
47229 #endif
47230 for (i = 0; swig_types_initial[i]; i++) {
47231 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47232 }
47233 typeinit = 1;
47234 }
47235 SWIG_InstallConstants(d,swig_const_table);
47236
47237
47238 #ifndef wxPyUSE_EXPORT
47239 // Make our API structure a CObject so other modules can import it
47240 // from this module.
47241 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47242 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47243 Py_XDECREF(cobj);
47244 #endif
47245
47246 {
47247 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47248 }
47249 {
47250 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47251 }
47252 {
47253 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47254 }
47255 {
47256 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47257 }
47258 {
47259 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47260 }
47261 {
47262 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47263 }
47264 {
47265 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47266 }
47267 {
47268 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47269 }
47270 {
47271 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47272 }
47273 {
47274 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47275 }
47276 {
47277 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47278 }
47279 {
47280 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47281 }
47282 {
47283 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47284 }
47285 {
47286 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47287 }
47288 {
47289 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47290 }
47291 {
47292 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47293 }
47294 {
47295 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47296 }
47297 {
47298 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47299 }
47300 {
47301 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47302 }
47303 {
47304 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47305 }
47306 {
47307 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47308 }
47309 {
47310 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47311 }
47312 {
47313 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47314 }
47315 {
47316 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47317 }
47318 {
47319 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47320 }
47321 {
47322 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47323 }
47324 {
47325 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47326 }
47327 {
47328 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47329 }
47330 {
47331 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47332 }
47333 {
47334 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47335 }
47336 {
47337 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47338 }
47339 {
47340 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47341 }
47342 {
47343 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47344 }
47345 {
47346 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47347 }
47348 {
47349 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47350 }
47351 {
47352 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47353 }
47354 {
47355 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47356 }
47357 {
47358 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47359 }
47360 {
47361 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47362 }
47363 {
47364 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47365 }
47366 {
47367 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47368 }
47369 {
47370 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47371 }
47372 {
47373 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47374 }
47375 {
47376 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47377 }
47378 {
47379 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47380 }
47381 {
47382 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47383 }
47384 {
47385 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47386 }
47387 {
47388 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47389 }
47390 {
47391 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47392 }
47393 {
47394 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47395 }
47396 {
47397 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47398 }
47399 {
47400 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47401 }
47402 {
47403 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47404 }
47405 {
47406 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47407 }
47408 {
47409 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47410 }
47411 {
47412 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47413 }
47414 {
47415 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47416 }
47417 {
47418 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47419 }
47420 {
47421 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47422 }
47423 {
47424 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47425 }
47426 {
47427 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47428 }
47429 {
47430 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47431 }
47432 {
47433 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47434 }
47435 {
47436 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47437 }
47438 {
47439 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47440 }
47441 {
47442 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47443 }
47444 {
47445 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47446 }
47447 {
47448 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47449 }
47450 {
47451 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47452 }
47453 {
47454 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47455 }
47456 {
47457 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47458 }
47459 {
47460 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47461 }
47462 {
47463 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47464 }
47465 {
47466 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47467 }
47468 {
47469 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47470 }
47471 {
47472 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47473 }
47474 {
47475 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47476 }
47477 {
47478 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47479 }
47480 {
47481 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47482 }
47483 {
47484 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47485 }
47486 {
47487 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47488 }
47489 {
47490 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47491 }
47492 {
47493 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47494 }
47495 {
47496 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47497 }
47498 {
47499 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47500 }
47501 {
47502 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47503 }
47504 {
47505 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47506 }
47507 {
47508 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47509 }
47510 {
47511 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47512 }
47513 {
47514 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47515 }
47516 {
47517 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47518 }
47519 {
47520 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47521 }
47522 {
47523 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47524 }
47525 {
47526 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47527 }
47528 {
47529 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47530 }
47531 {
47532 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47533 }
47534 {
47535 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47536 }
47537 {
47538 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47539 }
47540 {
47541 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47542 }
47543 {
47544 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47545 }
47546 {
47547 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47548 }
47549 {
47550 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47551 }
47552 {
47553 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47554 }
47555 {
47556 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47557 }
47558 {
47559 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47560 }
47561 {
47562 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47563 }
47564 {
47565 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47566 }
47567 {
47568 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47569 }
47570 {
47571 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47572 }
47573 {
47574 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47575 }
47576 {
47577 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47578 }
47579 {
47580 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47581 }
47582 {
47583 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47584 }
47585 {
47586 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47587 }
47588 {
47589 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47590 }
47591 {
47592 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47593 }
47594 {
47595 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47596 }
47597 {
47598 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47599 }
47600 {
47601 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47602 }
47603 {
47604 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47605 }
47606 {
47607 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47608 }
47609 {
47610 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47611 }
47612 {
47613 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47614 }
47615 {
47616 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47617 }
47618 {
47619 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47620 }
47621 {
47622 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47623 }
47624 {
47625 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47626 }
47627 {
47628 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47629 }
47630 {
47631 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47632 }
47633 {
47634 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47635 }
47636 {
47637 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47638 }
47639 {
47640 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47641 }
47642 {
47643 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47644 }
47645 {
47646 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47647 }
47648 {
47649 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47650 }
47651 {
47652 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47653 }
47654 {
47655 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47656 }
47657 {
47658 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47659 }
47660 {
47661 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47662 }
47663 {
47664 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47665 }
47666 {
47667 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47668 }
47669 {
47670 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47671 }
47672 {
47673 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47674 }
47675 {
47676 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47677 }
47678 {
47679 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47680 }
47681 {
47682 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47683 }
47684 {
47685 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47686 }
47687 {
47688 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47689 }
47690 {
47691 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47692 }
47693 {
47694 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47695 }
47696 {
47697 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47698 }
47699 {
47700 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47701 }
47702 {
47703 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47704 }
47705 {
47706 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47707 }
47708 {
47709 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47710 }
47711 {
47712 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47713 }
47714 {
47715 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47716 }
47717 {
47718 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47719 }
47720 {
47721 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47722 }
47723 {
47724 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47725 }
47726 {
47727 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47728 }
47729 {
47730 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47731 }
47732 {
47733 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47734 }
47735 {
47736 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47737 }
47738 {
47739 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47740 }
47741 {
47742 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47743 }
47744 {
47745 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47746 }
47747 {
47748 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47749 }
47750 {
47751 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47752 }
47753 {
47754 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47755 }
47756 {
47757 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47758 }
47759 {
47760 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47761 }
47762 {
47763 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47764 }
47765 {
47766 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47767 }
47768 {
47769 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47770 }
47771 {
47772 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48823 }
48824 {
48825 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48826 }
48827 {
48828 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48829 }
48830 {
48831 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48832 }
48833 {
48834 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48835 }
48836 {
48837 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48838 }
48839 {
48840 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48850 }
48851 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48852 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48853 {
48854 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49005 }
49006 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49007 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49008 {
49009 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49016 }
49017
49018 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49019
49020
49021 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49022
49023 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49024 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49025 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49026 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49027 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49028 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49029 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49030 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49031 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49032 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49033 {
49034 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49038 }
49039 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49040 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49041 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49042 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49043 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49044 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49045 {
49046 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49092 }
49093 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49094 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49095 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49096 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49097 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49098 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49099 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49100 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49101 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49102 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49103 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49104 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49105 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49106 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49107 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49108 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49109 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49110 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49111 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49112 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49113 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49114 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49115 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49116 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49117 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49118 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49119 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49120 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49121 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49122 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49123 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49124 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49125 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49126 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49127 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49128 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49129 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49130 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49131 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49132 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49133 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49134 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49135 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49136 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49137 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49138 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49139 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49140 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49141 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49142 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49143 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49144 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49145 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49146 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49147 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49148 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49149 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49150 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49151 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49152 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49153 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49154 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49155 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49156 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49157 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49158 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49159 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49160 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49161 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49162 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49163 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49164 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49165 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49166 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49167 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49168 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49169 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49170 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49171 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49172 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49173 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49174 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49175 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49176 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49177 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49178 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49179 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49180 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49181 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49182 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49183 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49184 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49185 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49186 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49187 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49188 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49189 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49190 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49191 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49192 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49193 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49194 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49195 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49196 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49197 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49198 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49199 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49200 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49201 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49202 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49203 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49204 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49205 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49206 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49207 {
49208 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49245 }
49246 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49247 {
49248 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49252 }
49253 {
49254 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49264 }
49265 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49266 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49267 {
49268 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49281 }
49282 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49283 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49284 {
49285 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49289 }
49290 {
49291 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49292 }
49293 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49294 {
49295 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49350 }
49351
49352 // Initialize threading, some globals and such
49353 __wxPyPreStart(d);
49354
49355
49356 // Although these are defined in __version__ they need to be here too so
49357 // that an assert can be done to ensure that the wxPython and the wxWindows
49358 // versions match.
49359 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49360 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49361 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49362
49363 }
49364
wxWidgets (Impactor)