]> 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
WXDLLIMPEXP_GIZMOS
[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 wxPyCBInputStream_copy,
1653
1654 wxPyInstance_Check,
1655 wxPySwigInstance_Check,
1656
1657 wxPyCheckForApp
1658
1659 };
1660
1661 #endif
1662
1663
1664 #if !WXWIN_COMPATIBILITY_2_4
1665 #define wxHIDE_READONLY 0
1666 #endif
1667
1668
1669 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1670 #define SWIG_From_int PyInt_FromLong
1671 /*@@*/
1672
1673
1674 #if ! wxUSE_HOTKEY
1675 enum wxHotkeyModifier
1676 {
1677 wxMOD_NONE = 0,
1678 wxMOD_ALT = 1,
1679 wxMOD_CONTROL = 2,
1680 wxMOD_SHIFT = 4,
1681 wxMOD_WIN = 8
1682 };
1683 #define wxEVT_HOTKEY 9999
1684 #endif
1685
1686 static const wxString wxPyEmptyString(wxEmptyString);
1687 static wxString wxObject_GetClassName(wxObject *self){
1688 return self->GetClassInfo()->GetClassName();
1689 }
1690 static void wxObject_Destroy(wxObject *self){
1691 delete self;
1692 }
1693
1694 #ifndef __WXMAC__
1695 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1696 #endif
1697
1698
1699 #include <limits.h>
1700
1701
1702 SWIGINTERN int
1703 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1704 const char *errmsg)
1705 {
1706 if (value < min_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is less than '%s' minimum %ld",
1710 value, errmsg, min_value);
1711 }
1712 return 0;
1713 } else if (value > max_value) {
1714 if (errmsg) {
1715 PyErr_Format(PyExc_OverflowError,
1716 "value %ld is greater than '%s' maximum %ld",
1717 value, errmsg, max_value);
1718 }
1719 return 0;
1720 }
1721 return 1;
1722 }
1723
1724
1725 SWIGINTERN int
1726 SWIG_AsVal_long(PyObject* obj, long* val)
1727 {
1728 if (PyNumber_Check(obj)) {
1729 if (val) *val = PyInt_AsLong(obj);
1730 return 1;
1731 }
1732 else {
1733 SWIG_type_error("number", obj);
1734 }
1735 return 0;
1736 }
1737
1738
1739 #if INT_MAX != LONG_MAX
1740 SWIGINTERN int
1741 SWIG_AsVal_int(PyObject *obj, int *val)
1742 {
1743 const char* errmsg = val ? "int" : (char*)0;
1744 long v;
1745 if (SWIG_AsVal_long(obj, &v)) {
1746 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1747 if (val) *val = (int)(v);
1748 return 1;
1749 } else {
1750 return 0;
1751 }
1752 } else {
1753 PyErr_Clear();
1754 }
1755 if (val) {
1756 SWIG_type_error(errmsg, obj);
1757 }
1758 return 0;
1759 }
1760 #else
1761 SWIGINTERNSHORT int
1762 SWIG_AsVal_int(PyObject *obj, int *val)
1763 {
1764 return SWIG_AsVal_long(obj,(long*)val);
1765 }
1766 #endif
1767
1768
1769 SWIGINTERNSHORT int
1770 SWIG_As_int(PyObject* obj)
1771 {
1772 int v;
1773 if (!SWIG_AsVal_int(obj, &v)) {
1774 /*
1775 this is needed to make valgrind/purify happier.
1776 */
1777 memset((void*)&v, 0, sizeof(int));
1778 }
1779 return v;
1780 }
1781
1782
1783 SWIGINTERNSHORT int
1784 SWIG_Check_int(PyObject* obj)
1785 {
1786 return SWIG_AsVal_int(obj, (int*)0);
1787 }
1788
1789 static PyObject *wxSize_Get(wxSize *self){
1790 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1791 PyObject* tup = PyTuple_New(2);
1792 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1793 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1794 wxPyEndBlockThreads(blocked);
1795 return tup;
1796 }
1797
1798 SWIGINTERN int
1799 SWIG_AsVal_double(PyObject *obj, double* val)
1800 {
1801 if (PyNumber_Check(obj)) {
1802 if (val) *val = PyFloat_AsDouble(obj);
1803 return 1;
1804 }
1805 else {
1806 SWIG_type_error("number", obj);
1807 }
1808 return 0;
1809 }
1810
1811
1812 SWIGINTERNSHORT double
1813 SWIG_As_double(PyObject* obj)
1814 {
1815 double v;
1816 if (!SWIG_AsVal_double(obj, &v)) {
1817 /*
1818 this is needed to make valgrind/purify happier.
1819 */
1820 memset((void*)&v, 0, sizeof(double));
1821 }
1822 return v;
1823 }
1824
1825
1826 SWIGINTERNSHORT int
1827 SWIG_Check_double(PyObject* obj)
1828 {
1829 return SWIG_AsVal_double(obj, (double*)0);
1830 }
1831
1832
1833 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1834 #define SWIG_From_double PyFloat_FromDouble
1835 /*@@*/
1836
1837 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1838 self->x = x;
1839 self->y = y;
1840 }
1841 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1842 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1843 PyObject* tup = PyTuple_New(2);
1844 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1845 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1846 wxPyEndBlockThreads(blocked);
1847 return tup;
1848 }
1849
1850 SWIGINTERNSHORT long
1851 SWIG_As_long(PyObject* obj)
1852 {
1853 long v;
1854 if (!SWIG_AsVal_long(obj, &v)) {
1855 /*
1856 this is needed to make valgrind/purify happier.
1857 */
1858 memset((void*)&v, 0, sizeof(long));
1859 }
1860 return v;
1861 }
1862
1863
1864 SWIGINTERNSHORT int
1865 SWIG_Check_long(PyObject* obj)
1866 {
1867 return SWIG_AsVal_long(obj, (long*)0);
1868 }
1869
1870 static void wxPoint_Set(wxPoint *self,long x,long y){
1871 self->x = x;
1872 self->y = y;
1873 }
1874 static PyObject *wxPoint_Get(wxPoint *self){
1875 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1876 PyObject* tup = PyTuple_New(2);
1877 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1878 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1879 wxPyEndBlockThreads(blocked);
1880 return tup;
1881 }
1882 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1883 self->x = x;
1884 self->y = y;
1885 self->width = width;
1886 self->height = height;
1887 }
1888 static PyObject *wxRect_Get(wxRect *self){
1889 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1890 PyObject* tup = PyTuple_New(4);
1891 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1892 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1893 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1894 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1895 wxPyEndBlockThreads(blocked);
1896 return tup;
1897 }
1898
1899 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1900 wxRegion reg1(*r1);
1901 wxRegion reg2(*r2);
1902 wxRect dest(0,0,0,0);
1903 PyObject* obj;
1904
1905 reg1.Intersect(reg2);
1906 dest = reg1.GetBox();
1907
1908 if (dest != wxRect(0,0,0,0)) {
1909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1910 wxRect* newRect = new wxRect(dest);
1911 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1912 wxPyEndBlockThreads(blocked);
1913 return obj;
1914 }
1915 Py_INCREF(Py_None);
1916 return Py_None;
1917 }
1918
1919
1920 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1921 PyObject* o2;
1922 PyObject* o3;
1923
1924 if (!target) {
1925 target = o;
1926 } else if (target == Py_None) {
1927 Py_DECREF(Py_None);
1928 target = o;
1929 } else {
1930 if (!PyTuple_Check(target)) {
1931 o2 = target;
1932 target = PyTuple_New(1);
1933 PyTuple_SetItem(target, 0, o2);
1934 }
1935 o3 = PyTuple_New(1);
1936 PyTuple_SetItem(o3, 0, o);
1937
1938 o2 = target;
1939 target = PySequence_Concat(o2, o3);
1940 Py_DECREF(o2);
1941 Py_DECREF(o3);
1942 }
1943 return target;
1944 }
1945
1946
1947 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1948 self->m_x = x;
1949 self->m_y = y;
1950 }
1951 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1952 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1953 PyObject* tup = PyTuple_New(2);
1954 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1955 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1956 wxPyEndBlockThreads(blocked);
1957 return tup;
1958 }
1959
1960 #include "wx/wxPython/pyistream.h"
1961
1962 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1963 wxInputStream* wxis = wxPyCBInputStream::create(p);
1964 if (wxis)
1965 return new wxPyInputStream(wxis);
1966 else
1967 return NULL;
1968 }
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_char(char c)
1972 {
1973 return PyString_FromStringAndSize(&c,1);
1974 }
1975
1976
1977 SWIGINTERNSHORT PyObject*
1978 SWIG_From_unsigned_SS_long(unsigned long value)
1979 {
1980 return (value > LONG_MAX) ?
1981 PyLong_FromUnsignedLong(value)
1982 : PyInt_FromLong((long)(value));
1983 }
1984
1985
1986 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1987 SWIGINTERN int
1988 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1989 {
1990 static swig_type_info* pchar_info = 0;
1991 char* vptr = 0;
1992 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1993 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1994 if (cptr) *cptr = vptr;
1995 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1996 return SWIG_OLDOBJ;
1997 } else {
1998 PyErr_Clear();
1999 if (PyString_Check(obj)) {
2000 if (cptr) {
2001 *cptr = PyString_AS_STRING(obj);
2002 if (psize) {
2003 *psize = PyString_GET_SIZE(obj) + 1;
2004 }
2005 }
2006 return SWIG_PYSTR;
2007 }
2008 }
2009 if (cptr) {
2010 SWIG_type_error("char *", obj);
2011 }
2012 return 0;
2013 }
2014
2015
2016 SWIGINTERN int
2017 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2018 {
2019 char* cptr; size_t csize;
2020 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2021 /* in C you can do:
2022
2023 char x[5] = "hello";
2024
2025 ie, assing the array using an extra '0' char.
2026 */
2027 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2028 if (csize <= size) {
2029 if (val) {
2030 if (csize) memcpy(val, cptr, csize);
2031 if (csize < size) memset(val + csize, 0, size - csize);
2032 }
2033 return 1;
2034 }
2035 }
2036 if (val) {
2037 PyErr_Format(PyExc_TypeError,
2038 "a char array of maximum size %lu is expected",
2039 (unsigned long) size);
2040 }
2041 return 0;
2042 }
2043
2044
2045 SWIGINTERN int
2046 SWIG_AsVal_char(PyObject *obj, char *val)
2047 {
2048 const char* errmsg = val ? "char" : (char*)0;
2049 long v;
2050 if (SWIG_AsVal_long(obj, &v)) {
2051 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2052 if (val) *val = (char)(v);
2053 return 1;
2054 } else {
2055 return 0;
2056 }
2057 } else {
2058 PyErr_Clear();
2059 return SWIG_AsCharArray(obj, val, 1);
2060 }
2061 }
2062
2063
2064 SWIGINTERNSHORT char
2065 SWIG_As_char(PyObject* obj)
2066 {
2067 char v;
2068 if (!SWIG_AsVal_char(obj, &v)) {
2069 /*
2070 this is needed to make valgrind/purify happier.
2071 */
2072 memset((void*)&v, 0, sizeof(char));
2073 }
2074 return v;
2075 }
2076
2077
2078 SWIGINTERNSHORT int
2079 SWIG_Check_char(PyObject* obj)
2080 {
2081 return SWIG_AsVal_char(obj, (char*)0);
2082 }
2083
2084
2085 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2086 #define SWIG_From_long PyInt_FromLong
2087 /*@@*/
2088
2089 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2090 // We use only strings for the streams, not unicode
2091 PyObject* str = PyObject_Str(obj);
2092 if (! str) {
2093 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2094 return;
2095 }
2096 self->Write(PyString_AS_STRING(str),
2097 PyString_GET_SIZE(str));
2098 Py_DECREF(str);
2099 }
2100
2101 #include "wx/wxPython/pyistream.h"
2102
2103
2104 class wxPyFileSystemHandler : public wxFileSystemHandler
2105 {
2106 public:
2107 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2108
2109 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2110 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2111 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2112 DEC_PYCALLBACK_STRING__pure(FindNext);
2113
2114 wxString GetProtocol(const wxString& location) {
2115 return wxFileSystemHandler::GetProtocol(location);
2116 }
2117
2118 wxString GetLeftLocation(const wxString& location) {
2119 return wxFileSystemHandler::GetLeftLocation(location);
2120 }
2121
2122 wxString GetAnchor(const wxString& location) {
2123 return wxFileSystemHandler::GetAnchor(location);
2124 }
2125
2126 wxString GetRightLocation(const wxString& location) {
2127 return wxFileSystemHandler::GetRightLocation(location);
2128 }
2129
2130 wxString GetMimeTypeFromExt(const wxString& location) {
2131 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2132 }
2133
2134 PYPRIVATE;
2135 };
2136
2137
2138 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2139 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2140 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2141 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2142
2143
2144 SWIGINTERN int
2145 SWIG_AsVal_bool(PyObject *obj, bool *val)
2146 {
2147 if (obj == Py_True) {
2148 if (val) *val = true;
2149 return 1;
2150 }
2151 if (obj == Py_False) {
2152 if (val) *val = false;
2153 return 1;
2154 }
2155 int res = 0;
2156 if (SWIG_AsVal_int(obj, &res)) {
2157 if (val) *val = res ? true : false;
2158 return 1;
2159 } else {
2160 PyErr_Clear();
2161 }
2162 if (val) {
2163 SWIG_type_error("bool", obj);
2164 }
2165 return 0;
2166 }
2167
2168
2169 SWIGINTERNSHORT bool
2170 SWIG_As_bool(PyObject* obj)
2171 {
2172 bool v;
2173 if (!SWIG_AsVal_bool(obj, &v)) {
2174 /*
2175 this is needed to make valgrind/purify happier.
2176 */
2177 memset((void*)&v, 0, sizeof(bool));
2178 }
2179 return v;
2180 }
2181
2182
2183 SWIGINTERNSHORT int
2184 SWIG_Check_bool(PyObject* obj)
2185 {
2186 return SWIG_AsVal_bool(obj, (bool*)0);
2187 }
2188
2189 static wxString FileSystem_URLToFileName(wxString const &url){
2190 wxFileName fname = wxFileSystem::URLToFileName(url);
2191 return fname.GetFullPath();
2192 }
2193
2194 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2195 wxImage& image,
2196 long type) {
2197 wxMemoryFSHandler::AddFile(filename, image, type);
2198 }
2199
2200 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2201 const wxBitmap& bitmap,
2202 long type) {
2203 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2204 }
2205
2206 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2207 PyObject* data) {
2208 if (! PyString_Check(data)) {
2209 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2210 "Expected string object"));
2211 return;
2212 }
2213
2214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2215 void* ptr = (void*)PyString_AsString(data);
2216 size_t size = PyString_Size(data);
2217 wxPyEndBlockThreads(blocked);
2218
2219 wxMemoryFSHandler::AddFile(filename, ptr, size);
2220 }
2221
2222
2223 #include "wx/wxPython/pyistream.h"
2224
2225
2226 SWIGINTERN int
2227 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2228 {
2229 long v = 0;
2230 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2231 SWIG_type_error("unsigned number", obj);
2232 }
2233 else if (val)
2234 *val = (unsigned long)v;
2235 return 1;
2236 }
2237
2238
2239 SWIGINTERNSHORT int
2240 SWIG_CheckUnsignedLongInRange(unsigned long value,
2241 unsigned long max_value,
2242 const char *errmsg)
2243 {
2244 if (value > max_value) {
2245 if (errmsg) {
2246 PyErr_Format(PyExc_OverflowError,
2247 "value %lu is greater than '%s' minimum %lu",
2248 value, errmsg, max_value);
2249 }
2250 return 0;
2251 }
2252 return 1;
2253 }
2254
2255
2256 SWIGINTERN int
2257 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2258 {
2259 const char* errmsg = val ? "unsigned char" : (char*)0;
2260 unsigned long v;
2261 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2262 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2263 if (val) *val = (unsigned char)(v);
2264 return 1;
2265 } else {
2266 return 0;
2267 }
2268 } else {
2269 PyErr_Clear();
2270 }
2271 if (val) {
2272 SWIG_type_error(errmsg, obj);
2273 }
2274 return 0;
2275 }
2276
2277
2278 SWIGINTERNSHORT unsigned char
2279 SWIG_As_unsigned_SS_char(PyObject* obj)
2280 {
2281 unsigned char v;
2282 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2283 /*
2284 this is needed to make valgrind/purify happier.
2285 */
2286 memset((void*)&v, 0, sizeof(unsigned char));
2287 }
2288 return v;
2289 }
2290
2291
2292 SWIGINTERNSHORT int
2293 SWIG_Check_unsigned_SS_char(PyObject* obj)
2294 {
2295 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2296 }
2297
2298
2299 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2300 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2301 /*@@*/
2302
2303
2304
2305 SWIGINTERNSHORT unsigned long
2306 SWIG_As_unsigned_SS_long(PyObject* obj)
2307 {
2308 unsigned long v;
2309 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2310 /*
2311 this is needed to make valgrind/purify happier.
2312 */
2313 memset((void*)&v, 0, sizeof(unsigned long));
2314 }
2315 return v;
2316 }
2317
2318
2319 SWIGINTERNSHORT int
2320 SWIG_Check_unsigned_SS_long(PyObject* obj)
2321 {
2322 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2323 }
2324
2325 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2326 wxImageHistogramEntry e = (*self)[key];
2327 return e.value;
2328 }
2329 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2330 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2331 wxImageHistogramEntry e = (*self)[key];
2332 return e.value;
2333 }
2334 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2335 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2336 colour.Green(),
2337 colour.Blue());
2338 wxImageHistogramEntry e = (*self)[key];
2339 return e.value;
2340 }
2341 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2342 if (width > 0 && height > 0)
2343 return new wxImage(width, height, clear);
2344 else
2345 return new wxImage;
2346 }
2347 static wxImage *new_wxImage(wxBitmap const &bitmap){
2348 return new wxImage(bitmap.ConvertToImage());
2349 }
2350 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2351 // Copy the source data so the wxImage can clean it up later
2352 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2353 if (copy == NULL) {
2354 PyErr_NoMemory();
2355 return NULL;
2356 }
2357 memcpy(copy, data, width*height*3);
2358 return new wxImage(width, height, copy, false);
2359 }
2360 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2361 // Copy the source data so the wxImage can clean it up later
2362 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2363 if (dcopy == NULL) {
2364 PyErr_NoMemory();
2365 return NULL;
2366 }
2367 memcpy(dcopy, data, width*height*3);
2368 unsigned char* acopy = (unsigned char*)malloc(width*height);
2369 if (acopy == NULL) {
2370 PyErr_NoMemory();
2371 return NULL;
2372 }
2373 memcpy(acopy, alpha, width*height);
2374
2375 return new wxImage(width, height, dcopy, acopy, false);
2376 }
2377 static wxSize wxImage_GetSize(wxImage *self){
2378 wxSize size(self->GetWidth(), self->GetHeight());
2379 return size;
2380 }
2381 static PyObject *wxImage_GetData(wxImage *self){
2382 unsigned char* data = self->GetData();
2383 int len = self->GetWidth() * self->GetHeight() * 3;
2384 PyObject* rv;
2385 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2386 return rv;
2387 }
2388 static void wxImage_SetData(wxImage *self,PyObject *data){
2389 unsigned char* dataPtr;
2390
2391 if (! PyString_Check(data)) {
2392 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2393 "Expected string object"));
2394 return /* NULL */ ;
2395 }
2396
2397 size_t len = self->GetWidth() * self->GetHeight() * 3;
2398 dataPtr = (unsigned char*) malloc(len);
2399 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2400 self->SetData(dataPtr);
2401 // wxImage takes ownership of dataPtr...
2402 }
2403 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2404 unsigned char* data = self->GetData();
2405 int len = self->GetWidth() * self->GetHeight() * 3;
2406 PyObject* rv;
2407 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2408 return rv;
2409 }
2410 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2411 unsigned char* buffer;
2412 int size;
2413
2414 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2415 if (!PyArg_Parse(data, "t#", &buffer, &size))
2416 goto done;
2417
2418 if (size != self->GetWidth() * self->GetHeight() * 3) {
2419 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2420 goto done;
2421 }
2422 self->SetData(buffer);
2423 done:
2424 wxPyEndBlockThreads(blocked);
2425 }
2426 static PyObject *wxImage_GetAlphaData(wxImage *self){
2427 unsigned char* data = self->GetAlpha();
2428 if (! data) {
2429 RETURN_NONE();
2430 } else {
2431 int len = self->GetWidth() * self->GetHeight();
2432 PyObject* rv;
2433 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2434 return rv;
2435 }
2436 }
2437 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2438 unsigned char* dataPtr;
2439
2440 if (! PyString_Check(data)) {
2441 PyErr_SetString(PyExc_TypeError, "Expected string object");
2442 return /* NULL */ ;
2443 }
2444
2445 size_t len = self->GetWidth() * self->GetHeight();
2446 dataPtr = (unsigned char*) malloc(len);
2447 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2448 self->SetAlpha(dataPtr);
2449 // wxImage takes ownership of dataPtr...
2450 }
2451 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2452 unsigned char* data = self->GetAlpha();
2453 int len = self->GetWidth() * self->GetHeight();
2454 PyObject* rv;
2455 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2456 return rv;
2457 }
2458 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2459 unsigned char* buffer;
2460 int size;
2461
2462 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2463 if (!PyArg_Parse(data, "t#", &buffer, &size))
2464 goto done;
2465
2466 if (size != self->GetWidth() * self->GetHeight()) {
2467 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2468 goto done;
2469 }
2470 self->SetAlpha(buffer);
2471 done:
2472 wxPyEndBlockThreads(blocked);
2473 }
2474 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2475 wxBitmap bitmap(*self, depth);
2476 return bitmap;
2477 }
2478 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2479 wxImage mono = self->ConvertToMono( red, green, blue );
2480 wxBitmap bitmap( mono, 1 );
2481 return bitmap;
2482 }
2483 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2484 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2485 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2487 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2491 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2492 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2493 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2494 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2495 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2496 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2497 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2498
2499 #include <wx/quantize.h>
2500
2501 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2502 return wxQuantize::Quantize(src, dest,
2503 //NULL, // palette
2504 desiredNoColours,
2505 NULL, // eightBitData
2506 flags);
2507 }
2508 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2509 if (PyCallable_Check(func)) {
2510 self->Connect(id, lastId, eventType,
2511 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2512 new wxPyCallback(func));
2513 }
2514 else if (func == Py_None) {
2515 self->Disconnect(id, lastId, eventType,
2516 (wxObjectEventFunction)
2517 &wxPyCallback::EventThunker);
2518 }
2519 else {
2520 wxPyBLOCK_THREADS(
2521 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2522 }
2523 }
2524 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2525 return self->Disconnect(id, lastId, eventType,
2526 (wxObjectEventFunction)
2527 &wxPyCallback::EventThunker);
2528 }
2529 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2530 if (_self && _self != Py_None) {
2531 self->SetClientObject(new wxPyOORClientData(_self, incref));
2532 }
2533 else {
2534 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2535 if (data) {
2536 self->SetClientObject(NULL); // This will delete it too
2537 }
2538 }
2539 }
2540
2541 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2542 #if wxUSE_UNICODE
2543 return self->GetUnicodeKey();
2544 #else
2545 return 0;
2546 #endif
2547 }
2548
2549 #if UINT_MAX < LONG_MAX
2550 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_long
2552 /*@@*/
2553 #else
2554 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2555 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2556 /*@@*/
2557 #endif
2558
2559
2560 #if UINT_MAX != ULONG_MAX
2561 SWIGINTERN int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 const char* errmsg = val ? "unsigned int" : (char*)0;
2565 unsigned long v;
2566 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2567 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2568 if (val) *val = (unsigned int)(v);
2569 return 1;
2570 }
2571 } else {
2572 PyErr_Clear();
2573 }
2574 if (val) {
2575 SWIG_type_error(errmsg, obj);
2576 }
2577 return 0;
2578 }
2579 #else
2580 SWIGINTERNSHORT unsigned int
2581 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2582 {
2583 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2584 }
2585 #endif
2586
2587
2588 SWIGINTERNSHORT unsigned int
2589 SWIG_As_unsigned_SS_int(PyObject* obj)
2590 {
2591 unsigned int v;
2592 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2593 /*
2594 this is needed to make valgrind/purify happier.
2595 */
2596 memset((void*)&v, 0, sizeof(unsigned int));
2597 }
2598 return v;
2599 }
2600
2601
2602 SWIGINTERNSHORT int
2603 SWIG_Check_unsigned_SS_int(PyObject* obj)
2604 {
2605 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2606 }
2607
2608 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2609 self->m_size = size;
2610 }
2611 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2612 int count = self->GetNumberOfFiles();
2613 wxString* files = self->GetFiles();
2614 PyObject* list = PyList_New(count);
2615
2616 if (!list) {
2617 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2618 return NULL;
2619 }
2620
2621 for (int i=0; i<count; i++) {
2622 PyList_SetItem(list, i, wx2PyString(files[i]));
2623 }
2624 return list;
2625 }
2626
2627
2628 static wxPyApp *new_wxPyApp(){
2629 wxPythonApp = new wxPyApp();
2630 return wxPythonApp;
2631 }
2632
2633 void wxApp_CleanUp() {
2634 __wxPyCleanup();
2635 }
2636
2637
2638 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2639
2640
2641 SWIGINTERNSHORT int
2642 SWIG_AsCharPtr(PyObject *obj, char **val)
2643 {
2644 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2645 return 1;
2646 }
2647 if (val) {
2648 PyErr_Clear();
2649 SWIG_type_error("char *", obj);
2650 }
2651 return 0;
2652 }
2653
2654
2655 SWIGINTERN PyObject *
2656 SWIG_FromCharPtr(const char* cptr)
2657 {
2658 if (cptr) {
2659 size_t size = strlen(cptr);
2660 if (size > INT_MAX) {
2661 return SWIG_NewPointerObj((char*)(cptr),
2662 SWIG_TypeQuery("char *"), 0);
2663 } else {
2664 if (size != 0) {
2665 return PyString_FromStringAndSize(cptr, size);
2666 } else {
2667 return PyString_FromString(cptr);
2668 }
2669 }
2670 }
2671 Py_INCREF(Py_None);
2672 return Py_None;
2673 }
2674
2675
2676 #ifdef __WXMAC__
2677
2678 // A dummy class that raises an exception if used...
2679 class wxEventLoop
2680 {
2681 public:
2682 wxEventLoop() { wxPyRaiseNotImplemented(); }
2683 int Run() { return 0; }
2684 void Exit(int rc = 0) {}
2685 bool Pending() const { return false; }
2686 bool Dispatch() { return false; }
2687 bool IsRunning() const { return false; }
2688 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2689 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2690 };
2691
2692 #else
2693
2694 #include <wx/evtloop.h>
2695
2696 #endif
2697
2698
2699
2700 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2701 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2702 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2703 static PyObject *wxWindow_GetChildren(wxWindow *self){
2704 wxWindowList& list = self->GetChildren();
2705 return wxPy_ConvertList(&list);
2706 }
2707 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2708 #if wxUSE_HOTKEY
2709 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2710 #else
2711 return false;
2712 #endif
2713 }
2714 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2715
2716
2717
2718 return false;
2719
2720 }
2721 static long wxWindow_GetHandle(wxWindow *self){
2722 return wxPyGetWinHandle(self);
2723 }
2724 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2725 self->AssociateHandle((WXWidget)handle);
2726 }
2727
2728 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2729 return wxWindow::FindWindowById(id, parent);
2730 }
2731
2732 wxWindow* wxFindWindowByName( const wxString& name,
2733 const wxWindow *parent = NULL ) {
2734 return wxWindow::FindWindowByName(name, parent);
2735 }
2736
2737 wxWindow* wxFindWindowByLabel( const wxString& label,
2738 const wxWindow *parent = NULL ) {
2739 return wxWindow::FindWindowByLabel(label, parent);
2740 }
2741
2742
2743 #ifdef __WXMSW__
2744 #include <wx/msw/private.h> // to get wxGetWindowId
2745 #endif
2746
2747
2748 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2749 #ifdef __WXMSW__
2750 WXHWND hWnd = (WXHWND)_hWnd;
2751 long id = wxGetWindowId(hWnd);
2752 wxWindow* win = new wxWindow;
2753 parent->AddChild(win);
2754 win->SetEventHandler(win);
2755 win->SetHWND(hWnd);
2756 win->SetId(id);
2757 win->SubclassWin(hWnd);
2758 win->AdoptAttributesFromHWND();
2759 win->SetupColours();
2760 return win;
2761 #else
2762 wxPyRaiseNotImplemented();
2763 return NULL;
2764 #endif
2765 }
2766
2767
2768 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2769 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2770 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2771
2772 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2773
2774 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2775 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2776 wxMenuItemList& list = self->GetMenuItems();
2777 return wxPy_ConvertList(&list);
2778 }
2779 static const wxString wxPyControlNameStr(wxControlNameStr);
2780 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2781 if (clientData) {
2782 wxPyClientData* data = new wxPyClientData(clientData);
2783 return self->Append(item, data);
2784 } else
2785 return self->Append(item);
2786 }
2787 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2788 if (clientData) {
2789 wxPyClientData* data = new wxPyClientData(clientData);
2790 return self->Insert(item, pos, data);
2791 } else
2792 return self->Insert(item, pos);
2793 }
2794 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2795 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2796 if (data) {
2797 Py_INCREF(data->m_obj);
2798 return data->m_obj;
2799 } else {
2800 Py_INCREF(Py_None);
2801 return Py_None;
2802 }
2803 }
2804 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2805 wxPyClientData* data = new wxPyClientData(clientData);
2806 self->SetClientObject(n, data);
2807 }
2808
2809
2810 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2811 wxPyUserData* data = NULL;
2812 if ( userData ) {
2813 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2814 data = new wxPyUserData(userData);
2815 wxPyEndBlockThreads(blocked);
2816 }
2817 return new wxSizerItem(window, proportion, flag, border, data);
2818 }
2819 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2820 wxPyUserData* data = NULL;
2821 if ( userData ) {
2822 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2823 data = new wxPyUserData(userData);
2824 wxPyEndBlockThreads(blocked);
2825 }
2826 return new wxSizerItem(width, height, proportion, flag, border, data);
2827 }
2828 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2829 wxPyUserData* data = NULL;
2830 if ( userData ) {
2831 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2832 data = new wxPyUserData(userData);
2833 wxPyEndBlockThreads(blocked);
2834 }
2835 return new wxSizerItem(sizer, proportion, flag, border, data);
2836 }
2837
2838 #include <float.h>
2839 SWIGINTERN int
2840 SWIG_CheckDoubleInRange(double value, double min_value,
2841 double max_value, const char* errmsg)
2842 {
2843 if (value < min_value) {
2844 if (errmsg) {
2845 PyErr_Format(PyExc_OverflowError,
2846 "value %g is less than %s minimum %g",
2847 value, errmsg, min_value);
2848 }
2849 return 0;
2850 } else if (value > max_value) {
2851 if (errmsg) {
2852 PyErr_Format(PyExc_OverflowError,
2853 "value %g is greater than %s maximum %g",
2854 value, errmsg, max_value);
2855 }
2856 return 0;
2857 }
2858 return 1;
2859 }
2860
2861
2862 SWIGINTERN int
2863 SWIG_AsVal_float(PyObject *obj, float *val)
2864 {
2865 const char* errmsg = val ? "float" : (char*)0;
2866 double v;
2867 if (SWIG_AsVal_double(obj, &v)) {
2868 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2869 if (val) *val = (float)(v);
2870 return 1;
2871 } else {
2872 return 0;
2873 }
2874 } else {
2875 PyErr_Clear();
2876 }
2877 if (val) {
2878 SWIG_type_error(errmsg, obj);
2879 }
2880 return 0;
2881 }
2882
2883
2884 SWIGINTERNSHORT float
2885 SWIG_As_float(PyObject* obj)
2886 {
2887 float v;
2888 if (!SWIG_AsVal_float(obj, &v)) {
2889 /*
2890 this is needed to make valgrind/purify happier.
2891 */
2892 memset((void*)&v, 0, sizeof(float));
2893 }
2894 return v;
2895 }
2896
2897
2898 SWIGINTERNSHORT int
2899 SWIG_Check_float(PyObject* obj)
2900 {
2901 return SWIG_AsVal_float(obj, (float*)0);
2902 }
2903
2904
2905 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2906 #define SWIG_From_float PyFloat_FromDouble
2907 /*@@*/
2908
2909 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2910 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2911 if (data) {
2912 Py_INCREF(data->m_obj);
2913 return data->m_obj;
2914 } else {
2915 Py_INCREF(Py_None);
2916 return Py_None;
2917 }
2918 }
2919
2920 // Figure out the type of the sizer item
2921
2922 struct wxPySizerItemInfo {
2923 wxPySizerItemInfo()
2924 : window(NULL), sizer(NULL), gotSize(false),
2925 size(wxDefaultSize), gotPos(false), pos(-1)
2926 {}
2927
2928 wxWindow* window;
2929 wxSizer* sizer;
2930 bool gotSize;
2931 wxSize size;
2932 bool gotPos;
2933 int pos;
2934 };
2935
2936 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2937
2938 wxPySizerItemInfo info;
2939 wxSize size;
2940 wxSize* sizePtr = &size;
2941
2942 // Find out what the type of the item is
2943 // try wxWindow
2944 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2945 PyErr_Clear();
2946 info.window = NULL;
2947
2948 // try wxSizer
2949 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2950 PyErr_Clear();
2951 info.sizer = NULL;
2952
2953 // try wxSize or (w,h)
2954 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2955 info.size = *sizePtr;
2956 info.gotSize = true;
2957 }
2958
2959 // or a single int
2960 if (checkIdx && PyInt_Check(item)) {
2961 info.pos = PyInt_AsLong(item);
2962 info.gotPos = true;
2963 }
2964 }
2965 }
2966
2967 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2968 // no expected type, figure out what kind of error message to generate
2969 if ( !checkSize && !checkIdx )
2970 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2971 else if ( checkSize && !checkIdx )
2972 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2973 else if ( !checkSize && checkIdx)
2974 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2975 else
2976 // can this one happen?
2977 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2978 }
2979
2980 return info;
2981 }
2982
2983 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2984 if (!self->GetClientObject())
2985 self->SetClientObject(new wxPyOORClientData(_self));
2986 }
2987 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2988
2989 wxPyUserData* data = NULL;
2990 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2991 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2992 if ( userData && (info.window || info.sizer || info.gotSize) )
2993 data = new wxPyUserData(userData);
2994 wxPyEndBlockThreads(blocked);
2995
2996 // Now call the real Add method if a valid item type was found
2997 if ( info.window )
2998 return self->Add(info.window, proportion, flag, border, data);
2999 else if ( info.sizer )
3000 return self->Add(info.sizer, proportion, flag, border, data);
3001 else if (info.gotSize)
3002 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3003 proportion, flag, border, data);
3004 else
3005 return NULL;
3006 }
3007 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3008
3009 wxPyUserData* data = NULL;
3010 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3011 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3012 if ( userData && (info.window || info.sizer || info.gotSize) )
3013 data = new wxPyUserData(userData);
3014 wxPyEndBlockThreads(blocked);
3015
3016 // Now call the real Insert method if a valid item type was found
3017 if ( info.window )
3018 return self->Insert(before, info.window, proportion, flag, border, data);
3019 else if ( info.sizer )
3020 return self->Insert(before, info.sizer, proportion, flag, border, data);
3021 else if (info.gotSize)
3022 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3023 proportion, flag, border, data);
3024 else
3025 return NULL;
3026 }
3027 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3028
3029 wxPyUserData* data = NULL;
3030 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3031 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3032 if ( userData && (info.window || info.sizer || info.gotSize) )
3033 data = new wxPyUserData(userData);
3034 wxPyEndBlockThreads(blocked);
3035
3036 // Now call the real Prepend method if a valid item type was found
3037 if ( info.window )
3038 return self->Prepend(info.window, proportion, flag, border, data);
3039 else if ( info.sizer )
3040 return self->Prepend(info.sizer, proportion, flag, border, data);
3041 else if (info.gotSize)
3042 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3043 proportion, flag, border, data);
3044 else
3045 return NULL;
3046 }
3047 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3050 wxPyEndBlockThreads(blocked);
3051 if ( info.window )
3052 return self->Remove(info.window);
3053 else if ( info.sizer )
3054 return self->Remove(info.sizer);
3055 else if ( info.gotPos )
3056 return self->Remove(info.pos);
3057 else
3058 return false;
3059 }
3060 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3061 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3062 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3063 wxPyEndBlockThreads(blocked);
3064 if ( info.window )
3065 return self->Detach(info.window);
3066 else if ( info.sizer )
3067 return self->Detach(info.sizer);
3068 else if ( info.gotPos )
3069 return self->Detach(info.pos);
3070 else
3071 return false;
3072 }
3073 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3074 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3075 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3076 wxPyEndBlockThreads(blocked);
3077 if ( info.window )
3078 return self->GetItem(info.window);
3079 else if ( info.sizer )
3080 return self->GetItem(info.sizer);
3081 else if ( info.gotPos )
3082 return self->GetItem(info.pos);
3083 else
3084 return NULL;
3085 }
3086 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3087 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3089 wxPyEndBlockThreads(blocked);
3090 if ( info.window )
3091 self->SetItemMinSize(info.window, size);
3092 else if ( info.sizer )
3093 self->SetItemMinSize(info.sizer, size);
3094 else if ( info.gotPos )
3095 self->SetItemMinSize(info.pos, size);
3096 }
3097 static PyObject *wxSizer_GetChildren(wxSizer *self){
3098 wxSizerItemList& list = self->GetChildren();
3099 return wxPy_ConvertList(&list);
3100 }
3101 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3102 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3103 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3104 wxPyEndBlockThreads(blocked);
3105 if ( info.window )
3106 return self->Show(info.window, show, recursive);
3107 else if ( info.sizer )
3108 return self->Show(info.sizer, show, recursive);
3109 else if ( info.gotPos )
3110 return self->Show(info.pos, show);
3111 else
3112 return false;
3113 }
3114 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3115 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3117 wxPyEndBlockThreads(blocked);
3118 if ( info.window )
3119 return self->IsShown(info.window);
3120 else if ( info.sizer )
3121 return self->IsShown(info.sizer);
3122 else if ( info.gotPos )
3123 return self->IsShown(info.pos);
3124 else
3125 return false;
3126 }
3127
3128 // See pyclasses.h
3129 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3130 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3131 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3132
3133
3134
3135
3136 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3137 {
3138 if (source == Py_None) {
3139 **obj = wxGBPosition(-1,-1);
3140 return true;
3141 }
3142 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3143 }
3144
3145 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3146 {
3147 if (source == Py_None) {
3148 **obj = wxGBSpan(-1,-1);
3149 return true;
3150 }
3151 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3152 }
3153
3154
3155 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3156 self->SetRow(row);
3157 self->SetCol(col);
3158 }
3159 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3161 PyObject* tup = PyTuple_New(2);
3162 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3163 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3164 wxPyEndBlockThreads(blocked);
3165 return tup;
3166 }
3167 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3168 self->SetRowspan(rowspan);
3169 self->SetColspan(colspan);
3170 }
3171 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 PyObject* tup = PyTuple_New(2);
3174 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3175 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3176 wxPyEndBlockThreads(blocked);
3177 return tup;
3178 }
3179 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3180 wxPyUserData* data = NULL;
3181 if ( userData ) {
3182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3183 data = new wxPyUserData(userData);
3184 wxPyEndBlockThreads(blocked);
3185 }
3186 return new wxGBSizerItem(window, pos, span, flag, border, data);
3187 }
3188 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3189 wxPyUserData* data = NULL;
3190 if ( userData ) {
3191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3192 data = new wxPyUserData(userData);
3193 wxPyEndBlockThreads(blocked);
3194 }
3195 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3196 }
3197 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3198 wxPyUserData* data = NULL;
3199 if ( userData ) {
3200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 data = new wxPyUserData(userData);
3202 wxPyEndBlockThreads(blocked);
3203 }
3204 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3205 }
3206 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3207 int row, col;
3208 self->GetEndPos(row, col);
3209 return wxGBPosition(row, col);
3210 }
3211 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3212
3213 wxPyUserData* data = NULL;
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3216 if ( userData && (info.window || info.sizer || info.gotSize) )
3217 data = new wxPyUserData(userData);
3218 wxPyEndBlockThreads(blocked);
3219
3220 // Now call the real Add method if a valid item type was found
3221 if ( info.window )
3222 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3223 else if ( info.sizer )
3224 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3225 else if (info.gotSize)
3226 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3227 pos, span, flag, border, data);
3228 return NULL;
3229 }
3230
3231
3232 #ifdef __cplusplus
3233 extern "C" {
3234 #endif
3235 static int _wrap_EmptyString_set(PyObject *) {
3236 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3237 return 1;
3238 }
3239
3240
3241 static PyObject *_wrap_EmptyString_get(void) {
3242 PyObject *pyobj;
3243
3244 {
3245 #if wxUSE_UNICODE
3246 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3247 #else
3248 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3249 #endif
3250 }
3251 return pyobj;
3252 }
3253
3254
3255 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3256 PyObject *resultobj;
3257 wxObject *arg1 = (wxObject *) 0 ;
3258 wxString result;
3259 PyObject * obj0 = 0 ;
3260 char *kwnames[] = {
3261 (char *) "self", NULL
3262 };
3263
3264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3266 if (SWIG_arg_fail(1)) SWIG_fail;
3267 {
3268 PyThreadState* __tstate = wxPyBeginAllowThreads();
3269 result = wxObject_GetClassName(arg1);
3270
3271 wxPyEndAllowThreads(__tstate);
3272 if (PyErr_Occurred()) SWIG_fail;
3273 }
3274 {
3275 #if wxUSE_UNICODE
3276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3277 #else
3278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3279 #endif
3280 }
3281 return resultobj;
3282 fail:
3283 return NULL;
3284 }
3285
3286
3287 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3288 PyObject *resultobj;
3289 wxObject *arg1 = (wxObject *) 0 ;
3290 PyObject * obj0 = 0 ;
3291 char *kwnames[] = {
3292 (char *) "self", NULL
3293 };
3294
3295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3297 if (SWIG_arg_fail(1)) SWIG_fail;
3298 {
3299 PyThreadState* __tstate = wxPyBeginAllowThreads();
3300 wxObject_Destroy(arg1);
3301
3302 wxPyEndAllowThreads(__tstate);
3303 if (PyErr_Occurred()) SWIG_fail;
3304 }
3305 Py_INCREF(Py_None); resultobj = Py_None;
3306 return resultobj;
3307 fail:
3308 return NULL;
3309 }
3310
3311
3312 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3313 PyObject *obj;
3314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3315 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3316 Py_INCREF(obj);
3317 return Py_BuildValue((char *)"");
3318 }
3319 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3320 PyObject *resultobj;
3321 wxSize *arg1 = (wxSize *) 0 ;
3322 int arg2 ;
3323 PyObject * obj0 = 0 ;
3324 PyObject * obj1 = 0 ;
3325 char *kwnames[] = {
3326 (char *) "self",(char *) "x", NULL
3327 };
3328
3329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3331 if (SWIG_arg_fail(1)) SWIG_fail;
3332 {
3333 arg2 = (int)(SWIG_As_int(obj1));
3334 if (SWIG_arg_fail(2)) SWIG_fail;
3335 }
3336 if (arg1) (arg1)->x = arg2;
3337
3338 Py_INCREF(Py_None); resultobj = Py_None;
3339 return resultobj;
3340 fail:
3341 return NULL;
3342 }
3343
3344
3345 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3346 PyObject *resultobj;
3347 wxSize *arg1 = (wxSize *) 0 ;
3348 int result;
3349 PyObject * obj0 = 0 ;
3350 char *kwnames[] = {
3351 (char *) "self", NULL
3352 };
3353
3354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3356 if (SWIG_arg_fail(1)) SWIG_fail;
3357 result = (int) ((arg1)->x);
3358
3359 {
3360 resultobj = SWIG_From_int((int)(result));
3361 }
3362 return resultobj;
3363 fail:
3364 return NULL;
3365 }
3366
3367
3368 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3369 PyObject *resultobj;
3370 wxSize *arg1 = (wxSize *) 0 ;
3371 int arg2 ;
3372 PyObject * obj0 = 0 ;
3373 PyObject * obj1 = 0 ;
3374 char *kwnames[] = {
3375 (char *) "self",(char *) "y", NULL
3376 };
3377
3378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3380 if (SWIG_arg_fail(1)) SWIG_fail;
3381 {
3382 arg2 = (int)(SWIG_As_int(obj1));
3383 if (SWIG_arg_fail(2)) SWIG_fail;
3384 }
3385 if (arg1) (arg1)->y = arg2;
3386
3387 Py_INCREF(Py_None); resultobj = Py_None;
3388 return resultobj;
3389 fail:
3390 return NULL;
3391 }
3392
3393
3394 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3395 PyObject *resultobj;
3396 wxSize *arg1 = (wxSize *) 0 ;
3397 int result;
3398 PyObject * obj0 = 0 ;
3399 char *kwnames[] = {
3400 (char *) "self", NULL
3401 };
3402
3403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3405 if (SWIG_arg_fail(1)) SWIG_fail;
3406 result = (int) ((arg1)->y);
3407
3408 {
3409 resultobj = SWIG_From_int((int)(result));
3410 }
3411 return resultobj;
3412 fail:
3413 return NULL;
3414 }
3415
3416
3417 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3418 PyObject *resultobj;
3419 int arg1 = (int) 0 ;
3420 int arg2 = (int) 0 ;
3421 wxSize *result;
3422 PyObject * obj0 = 0 ;
3423 PyObject * obj1 = 0 ;
3424 char *kwnames[] = {
3425 (char *) "w",(char *) "h", NULL
3426 };
3427
3428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3429 if (obj0) {
3430 {
3431 arg1 = (int)(SWIG_As_int(obj0));
3432 if (SWIG_arg_fail(1)) SWIG_fail;
3433 }
3434 }
3435 if (obj1) {
3436 {
3437 arg2 = (int)(SWIG_As_int(obj1));
3438 if (SWIG_arg_fail(2)) SWIG_fail;
3439 }
3440 }
3441 {
3442 PyThreadState* __tstate = wxPyBeginAllowThreads();
3443 result = (wxSize *)new wxSize(arg1,arg2);
3444
3445 wxPyEndAllowThreads(__tstate);
3446 if (PyErr_Occurred()) SWIG_fail;
3447 }
3448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3449 return resultobj;
3450 fail:
3451 return NULL;
3452 }
3453
3454
3455 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3456 PyObject *resultobj;
3457 wxSize *arg1 = (wxSize *) 0 ;
3458 PyObject * obj0 = 0 ;
3459 char *kwnames[] = {
3460 (char *) "self", NULL
3461 };
3462
3463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3465 if (SWIG_arg_fail(1)) SWIG_fail;
3466 {
3467 PyThreadState* __tstate = wxPyBeginAllowThreads();
3468 delete arg1;
3469
3470 wxPyEndAllowThreads(__tstate);
3471 if (PyErr_Occurred()) SWIG_fail;
3472 }
3473 Py_INCREF(Py_None); resultobj = Py_None;
3474 return resultobj;
3475 fail:
3476 return NULL;
3477 }
3478
3479
3480 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3481 PyObject *resultobj;
3482 wxSize *arg1 = (wxSize *) 0 ;
3483 wxSize *arg2 = 0 ;
3484 bool result;
3485 wxSize temp2 ;
3486 PyObject * obj0 = 0 ;
3487 PyObject * obj1 = 0 ;
3488 char *kwnames[] = {
3489 (char *) "self",(char *) "sz", NULL
3490 };
3491
3492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3494 if (SWIG_arg_fail(1)) SWIG_fail;
3495 {
3496 arg2 = &temp2;
3497 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3498 }
3499 {
3500 PyThreadState* __tstate = wxPyBeginAllowThreads();
3501 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3502
3503 wxPyEndAllowThreads(__tstate);
3504 if (PyErr_Occurred()) SWIG_fail;
3505 }
3506 {
3507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3508 }
3509 return resultobj;
3510 fail:
3511 return NULL;
3512 }
3513
3514
3515 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3516 PyObject *resultobj;
3517 wxSize *arg1 = (wxSize *) 0 ;
3518 wxSize *arg2 = 0 ;
3519 bool result;
3520 wxSize temp2 ;
3521 PyObject * obj0 = 0 ;
3522 PyObject * obj1 = 0 ;
3523 char *kwnames[] = {
3524 (char *) "self",(char *) "sz", NULL
3525 };
3526
3527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3529 if (SWIG_arg_fail(1)) SWIG_fail;
3530 {
3531 arg2 = &temp2;
3532 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3533 }
3534 {
3535 PyThreadState* __tstate = wxPyBeginAllowThreads();
3536 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3537
3538 wxPyEndAllowThreads(__tstate);
3539 if (PyErr_Occurred()) SWIG_fail;
3540 }
3541 {
3542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3543 }
3544 return resultobj;
3545 fail:
3546 return NULL;
3547 }
3548
3549
3550 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3551 PyObject *resultobj;
3552 wxSize *arg1 = (wxSize *) 0 ;
3553 wxSize *arg2 = 0 ;
3554 wxSize result;
3555 wxSize temp2 ;
3556 PyObject * obj0 = 0 ;
3557 PyObject * obj1 = 0 ;
3558 char *kwnames[] = {
3559 (char *) "self",(char *) "sz", NULL
3560 };
3561
3562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3564 if (SWIG_arg_fail(1)) SWIG_fail;
3565 {
3566 arg2 = &temp2;
3567 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3568 }
3569 {
3570 PyThreadState* __tstate = wxPyBeginAllowThreads();
3571 result = (arg1)->operator +((wxSize const &)*arg2);
3572
3573 wxPyEndAllowThreads(__tstate);
3574 if (PyErr_Occurred()) SWIG_fail;
3575 }
3576 {
3577 wxSize * resultptr;
3578 resultptr = new wxSize((wxSize &)(result));
3579 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3580 }
3581 return resultobj;
3582 fail:
3583 return NULL;
3584 }
3585
3586
3587 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3588 PyObject *resultobj;
3589 wxSize *arg1 = (wxSize *) 0 ;
3590 wxSize *arg2 = 0 ;
3591 wxSize result;
3592 wxSize temp2 ;
3593 PyObject * obj0 = 0 ;
3594 PyObject * obj1 = 0 ;
3595 char *kwnames[] = {
3596 (char *) "self",(char *) "sz", NULL
3597 };
3598
3599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3601 if (SWIG_arg_fail(1)) SWIG_fail;
3602 {
3603 arg2 = &temp2;
3604 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3605 }
3606 {
3607 PyThreadState* __tstate = wxPyBeginAllowThreads();
3608 result = (arg1)->operator -((wxSize const &)*arg2);
3609
3610 wxPyEndAllowThreads(__tstate);
3611 if (PyErr_Occurred()) SWIG_fail;
3612 }
3613 {
3614 wxSize * resultptr;
3615 resultptr = new wxSize((wxSize &)(result));
3616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3617 }
3618 return resultobj;
3619 fail:
3620 return NULL;
3621 }
3622
3623
3624 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3625 PyObject *resultobj;
3626 wxSize *arg1 = (wxSize *) 0 ;
3627 wxSize *arg2 = 0 ;
3628 wxSize temp2 ;
3629 PyObject * obj0 = 0 ;
3630 PyObject * obj1 = 0 ;
3631 char *kwnames[] = {
3632 (char *) "self",(char *) "sz", NULL
3633 };
3634
3635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3637 if (SWIG_arg_fail(1)) SWIG_fail;
3638 {
3639 arg2 = &temp2;
3640 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3641 }
3642 {
3643 PyThreadState* __tstate = wxPyBeginAllowThreads();
3644 (arg1)->IncTo((wxSize const &)*arg2);
3645
3646 wxPyEndAllowThreads(__tstate);
3647 if (PyErr_Occurred()) SWIG_fail;
3648 }
3649 Py_INCREF(Py_None); resultobj = Py_None;
3650 return resultobj;
3651 fail:
3652 return NULL;
3653 }
3654
3655
3656 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3657 PyObject *resultobj;
3658 wxSize *arg1 = (wxSize *) 0 ;
3659 wxSize *arg2 = 0 ;
3660 wxSize temp2 ;
3661 PyObject * obj0 = 0 ;
3662 PyObject * obj1 = 0 ;
3663 char *kwnames[] = {
3664 (char *) "self",(char *) "sz", NULL
3665 };
3666
3667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3669 if (SWIG_arg_fail(1)) SWIG_fail;
3670 {
3671 arg2 = &temp2;
3672 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3673 }
3674 {
3675 PyThreadState* __tstate = wxPyBeginAllowThreads();
3676 (arg1)->DecTo((wxSize const &)*arg2);
3677
3678 wxPyEndAllowThreads(__tstate);
3679 if (PyErr_Occurred()) SWIG_fail;
3680 }
3681 Py_INCREF(Py_None); resultobj = Py_None;
3682 return resultobj;
3683 fail:
3684 return NULL;
3685 }
3686
3687
3688 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3689 PyObject *resultobj;
3690 wxSize *arg1 = (wxSize *) 0 ;
3691 int arg2 ;
3692 int arg3 ;
3693 PyObject * obj0 = 0 ;
3694 PyObject * obj1 = 0 ;
3695 PyObject * obj2 = 0 ;
3696 char *kwnames[] = {
3697 (char *) "self",(char *) "w",(char *) "h", NULL
3698 };
3699
3700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3702 if (SWIG_arg_fail(1)) SWIG_fail;
3703 {
3704 arg2 = (int)(SWIG_As_int(obj1));
3705 if (SWIG_arg_fail(2)) SWIG_fail;
3706 }
3707 {
3708 arg3 = (int)(SWIG_As_int(obj2));
3709 if (SWIG_arg_fail(3)) SWIG_fail;
3710 }
3711 {
3712 PyThreadState* __tstate = wxPyBeginAllowThreads();
3713 (arg1)->Set(arg2,arg3);
3714
3715 wxPyEndAllowThreads(__tstate);
3716 if (PyErr_Occurred()) SWIG_fail;
3717 }
3718 Py_INCREF(Py_None); resultobj = Py_None;
3719 return resultobj;
3720 fail:
3721 return NULL;
3722 }
3723
3724
3725 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3726 PyObject *resultobj;
3727 wxSize *arg1 = (wxSize *) 0 ;
3728 int arg2 ;
3729 PyObject * obj0 = 0 ;
3730 PyObject * obj1 = 0 ;
3731 char *kwnames[] = {
3732 (char *) "self",(char *) "w", NULL
3733 };
3734
3735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3737 if (SWIG_arg_fail(1)) SWIG_fail;
3738 {
3739 arg2 = (int)(SWIG_As_int(obj1));
3740 if (SWIG_arg_fail(2)) SWIG_fail;
3741 }
3742 {
3743 PyThreadState* __tstate = wxPyBeginAllowThreads();
3744 (arg1)->SetWidth(arg2);
3745
3746 wxPyEndAllowThreads(__tstate);
3747 if (PyErr_Occurred()) SWIG_fail;
3748 }
3749 Py_INCREF(Py_None); resultobj = Py_None;
3750 return resultobj;
3751 fail:
3752 return NULL;
3753 }
3754
3755
3756 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3757 PyObject *resultobj;
3758 wxSize *arg1 = (wxSize *) 0 ;
3759 int arg2 ;
3760 PyObject * obj0 = 0 ;
3761 PyObject * obj1 = 0 ;
3762 char *kwnames[] = {
3763 (char *) "self",(char *) "h", NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(1)) SWIG_fail;
3769 {
3770 arg2 = (int)(SWIG_As_int(obj1));
3771 if (SWIG_arg_fail(2)) SWIG_fail;
3772 }
3773 {
3774 PyThreadState* __tstate = wxPyBeginAllowThreads();
3775 (arg1)->SetHeight(arg2);
3776
3777 wxPyEndAllowThreads(__tstate);
3778 if (PyErr_Occurred()) SWIG_fail;
3779 }
3780 Py_INCREF(Py_None); resultobj = Py_None;
3781 return resultobj;
3782 fail:
3783 return NULL;
3784 }
3785
3786
3787 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3788 PyObject *resultobj;
3789 wxSize *arg1 = (wxSize *) 0 ;
3790 int result;
3791 PyObject * obj0 = 0 ;
3792 char *kwnames[] = {
3793 (char *) "self", NULL
3794 };
3795
3796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3798 if (SWIG_arg_fail(1)) SWIG_fail;
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 result = (int)((wxSize const *)arg1)->GetWidth();
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 {
3807 resultobj = SWIG_From_int((int)(result));
3808 }
3809 return resultobj;
3810 fail:
3811 return NULL;
3812 }
3813
3814
3815 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj;
3817 wxSize *arg1 = (wxSize *) 0 ;
3818 int result;
3819 PyObject * obj0 = 0 ;
3820 char *kwnames[] = {
3821 (char *) "self", NULL
3822 };
3823
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3826 if (SWIG_arg_fail(1)) SWIG_fail;
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 result = (int)((wxSize const *)arg1)->GetHeight();
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 {
3835 resultobj = SWIG_From_int((int)(result));
3836 }
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj;
3845 wxSize *arg1 = (wxSize *) 0 ;
3846 bool result;
3847 PyObject * obj0 = 0 ;
3848 char *kwnames[] = {
3849 (char *) "self", NULL
3850 };
3851
3852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3854 if (SWIG_arg_fail(1)) SWIG_fail;
3855 {
3856 PyThreadState* __tstate = wxPyBeginAllowThreads();
3857 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3858
3859 wxPyEndAllowThreads(__tstate);
3860 if (PyErr_Occurred()) SWIG_fail;
3861 }
3862 {
3863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3864 }
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 wxSize *arg1 = (wxSize *) 0 ;
3874 wxSize *arg2 = 0 ;
3875 wxSize temp2 ;
3876 PyObject * obj0 = 0 ;
3877 PyObject * obj1 = 0 ;
3878 char *kwnames[] = {
3879 (char *) "self",(char *) "size", NULL
3880 };
3881
3882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3884 if (SWIG_arg_fail(1)) SWIG_fail;
3885 {
3886 arg2 = &temp2;
3887 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3888 }
3889 {
3890 PyThreadState* __tstate = wxPyBeginAllowThreads();
3891 (arg1)->SetDefaults((wxSize const &)*arg2);
3892
3893 wxPyEndAllowThreads(__tstate);
3894 if (PyErr_Occurred()) SWIG_fail;
3895 }
3896 Py_INCREF(Py_None); resultobj = Py_None;
3897 return resultobj;
3898 fail:
3899 return NULL;
3900 }
3901
3902
3903 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3904 PyObject *resultobj;
3905 wxSize *arg1 = (wxSize *) 0 ;
3906 PyObject *result;
3907 PyObject * obj0 = 0 ;
3908 char *kwnames[] = {
3909 (char *) "self", NULL
3910 };
3911
3912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3914 if (SWIG_arg_fail(1)) SWIG_fail;
3915 {
3916 PyThreadState* __tstate = wxPyBeginAllowThreads();
3917 result = (PyObject *)wxSize_Get(arg1);
3918
3919 wxPyEndAllowThreads(__tstate);
3920 if (PyErr_Occurred()) SWIG_fail;
3921 }
3922 resultobj = result;
3923 return resultobj;
3924 fail:
3925 return NULL;
3926 }
3927
3928
3929 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3930 PyObject *obj;
3931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3932 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3933 Py_INCREF(obj);
3934 return Py_BuildValue((char *)"");
3935 }
3936 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3937 PyObject *resultobj;
3938 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3939 double arg2 ;
3940 PyObject * obj0 = 0 ;
3941 PyObject * obj1 = 0 ;
3942 char *kwnames[] = {
3943 (char *) "self",(char *) "x", NULL
3944 };
3945
3946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3948 if (SWIG_arg_fail(1)) SWIG_fail;
3949 {
3950 arg2 = (double)(SWIG_As_double(obj1));
3951 if (SWIG_arg_fail(2)) SWIG_fail;
3952 }
3953 if (arg1) (arg1)->x = arg2;
3954
3955 Py_INCREF(Py_None); resultobj = Py_None;
3956 return resultobj;
3957 fail:
3958 return NULL;
3959 }
3960
3961
3962 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3963 PyObject *resultobj;
3964 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3965 double result;
3966 PyObject * obj0 = 0 ;
3967 char *kwnames[] = {
3968 (char *) "self", NULL
3969 };
3970
3971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3973 if (SWIG_arg_fail(1)) SWIG_fail;
3974 result = (double) ((arg1)->x);
3975
3976 {
3977 resultobj = SWIG_From_double((double)(result));
3978 }
3979 return resultobj;
3980 fail:
3981 return NULL;
3982 }
3983
3984
3985 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3986 PyObject *resultobj;
3987 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3988 double arg2 ;
3989 PyObject * obj0 = 0 ;
3990 PyObject * obj1 = 0 ;
3991 char *kwnames[] = {
3992 (char *) "self",(char *) "y", NULL
3993 };
3994
3995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3997 if (SWIG_arg_fail(1)) SWIG_fail;
3998 {
3999 arg2 = (double)(SWIG_As_double(obj1));
4000 if (SWIG_arg_fail(2)) SWIG_fail;
4001 }
4002 if (arg1) (arg1)->y = arg2;
4003
4004 Py_INCREF(Py_None); resultobj = Py_None;
4005 return resultobj;
4006 fail:
4007 return NULL;
4008 }
4009
4010
4011 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4012 PyObject *resultobj;
4013 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4014 double result;
4015 PyObject * obj0 = 0 ;
4016 char *kwnames[] = {
4017 (char *) "self", NULL
4018 };
4019
4020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4022 if (SWIG_arg_fail(1)) SWIG_fail;
4023 result = (double) ((arg1)->y);
4024
4025 {
4026 resultobj = SWIG_From_double((double)(result));
4027 }
4028 return resultobj;
4029 fail:
4030 return NULL;
4031 }
4032
4033
4034 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4035 PyObject *resultobj;
4036 double arg1 = (double) 0.0 ;
4037 double arg2 = (double) 0.0 ;
4038 wxRealPoint *result;
4039 PyObject * obj0 = 0 ;
4040 PyObject * obj1 = 0 ;
4041 char *kwnames[] = {
4042 (char *) "x",(char *) "y", NULL
4043 };
4044
4045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4046 if (obj0) {
4047 {
4048 arg1 = (double)(SWIG_As_double(obj0));
4049 if (SWIG_arg_fail(1)) SWIG_fail;
4050 }
4051 }
4052 if (obj1) {
4053 {
4054 arg2 = (double)(SWIG_As_double(obj1));
4055 if (SWIG_arg_fail(2)) SWIG_fail;
4056 }
4057 }
4058 {
4059 PyThreadState* __tstate = wxPyBeginAllowThreads();
4060 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4061
4062 wxPyEndAllowThreads(__tstate);
4063 if (PyErr_Occurred()) SWIG_fail;
4064 }
4065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4066 return resultobj;
4067 fail:
4068 return NULL;
4069 }
4070
4071
4072 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4073 PyObject *resultobj;
4074 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4075 PyObject * obj0 = 0 ;
4076 char *kwnames[] = {
4077 (char *) "self", NULL
4078 };
4079
4080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4082 if (SWIG_arg_fail(1)) SWIG_fail;
4083 {
4084 PyThreadState* __tstate = wxPyBeginAllowThreads();
4085 delete arg1;
4086
4087 wxPyEndAllowThreads(__tstate);
4088 if (PyErr_Occurred()) SWIG_fail;
4089 }
4090 Py_INCREF(Py_None); resultobj = Py_None;
4091 return resultobj;
4092 fail:
4093 return NULL;
4094 }
4095
4096
4097 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4098 PyObject *resultobj;
4099 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4100 wxRealPoint *arg2 = 0 ;
4101 bool result;
4102 wxRealPoint temp2 ;
4103 PyObject * obj0 = 0 ;
4104 PyObject * obj1 = 0 ;
4105 char *kwnames[] = {
4106 (char *) "self",(char *) "pt", NULL
4107 };
4108
4109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4111 if (SWIG_arg_fail(1)) SWIG_fail;
4112 {
4113 arg2 = &temp2;
4114 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4115 }
4116 {
4117 PyThreadState* __tstate = wxPyBeginAllowThreads();
4118 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4119
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 {
4124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4125 }
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4133 PyObject *resultobj;
4134 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4135 wxRealPoint *arg2 = 0 ;
4136 bool result;
4137 wxRealPoint temp2 ;
4138 PyObject * obj0 = 0 ;
4139 PyObject * obj1 = 0 ;
4140 char *kwnames[] = {
4141 (char *) "self",(char *) "pt", NULL
4142 };
4143
4144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4146 if (SWIG_arg_fail(1)) SWIG_fail;
4147 {
4148 arg2 = &temp2;
4149 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4150 }
4151 {
4152 PyThreadState* __tstate = wxPyBeginAllowThreads();
4153 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4154
4155 wxPyEndAllowThreads(__tstate);
4156 if (PyErr_Occurred()) SWIG_fail;
4157 }
4158 {
4159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4160 }
4161 return resultobj;
4162 fail:
4163 return NULL;
4164 }
4165
4166
4167 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4168 PyObject *resultobj;
4169 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4170 wxRealPoint *arg2 = 0 ;
4171 wxRealPoint result;
4172 wxRealPoint temp2 ;
4173 PyObject * obj0 = 0 ;
4174 PyObject * obj1 = 0 ;
4175 char *kwnames[] = {
4176 (char *) "self",(char *) "pt", NULL
4177 };
4178
4179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4181 if (SWIG_arg_fail(1)) SWIG_fail;
4182 {
4183 arg2 = &temp2;
4184 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4185 }
4186 {
4187 PyThreadState* __tstate = wxPyBeginAllowThreads();
4188 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4189
4190 wxPyEndAllowThreads(__tstate);
4191 if (PyErr_Occurred()) SWIG_fail;
4192 }
4193 {
4194 wxRealPoint * resultptr;
4195 resultptr = new wxRealPoint((wxRealPoint &)(result));
4196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4197 }
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
4204 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4205 PyObject *resultobj;
4206 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4207 wxRealPoint *arg2 = 0 ;
4208 wxRealPoint result;
4209 wxRealPoint temp2 ;
4210 PyObject * obj0 = 0 ;
4211 PyObject * obj1 = 0 ;
4212 char *kwnames[] = {
4213 (char *) "self",(char *) "pt", NULL
4214 };
4215
4216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4218 if (SWIG_arg_fail(1)) SWIG_fail;
4219 {
4220 arg2 = &temp2;
4221 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4222 }
4223 {
4224 PyThreadState* __tstate = wxPyBeginAllowThreads();
4225 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4226
4227 wxPyEndAllowThreads(__tstate);
4228 if (PyErr_Occurred()) SWIG_fail;
4229 }
4230 {
4231 wxRealPoint * resultptr;
4232 resultptr = new wxRealPoint((wxRealPoint &)(result));
4233 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4234 }
4235 return resultobj;
4236 fail:
4237 return NULL;
4238 }
4239
4240
4241 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4242 PyObject *resultobj;
4243 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4244 double arg2 ;
4245 double arg3 ;
4246 PyObject * obj0 = 0 ;
4247 PyObject * obj1 = 0 ;
4248 PyObject * obj2 = 0 ;
4249 char *kwnames[] = {
4250 (char *) "self",(char *) "x",(char *) "y", NULL
4251 };
4252
4253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4255 if (SWIG_arg_fail(1)) SWIG_fail;
4256 {
4257 arg2 = (double)(SWIG_As_double(obj1));
4258 if (SWIG_arg_fail(2)) SWIG_fail;
4259 }
4260 {
4261 arg3 = (double)(SWIG_As_double(obj2));
4262 if (SWIG_arg_fail(3)) SWIG_fail;
4263 }
4264 {
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 wxRealPoint_Set(arg1,arg2,arg3);
4267
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 Py_INCREF(Py_None); resultobj = Py_None;
4272 return resultobj;
4273 fail:
4274 return NULL;
4275 }
4276
4277
4278 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4279 PyObject *resultobj;
4280 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4281 PyObject *result;
4282 PyObject * obj0 = 0 ;
4283 char *kwnames[] = {
4284 (char *) "self", NULL
4285 };
4286
4287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4289 if (SWIG_arg_fail(1)) SWIG_fail;
4290 {
4291 PyThreadState* __tstate = wxPyBeginAllowThreads();
4292 result = (PyObject *)wxRealPoint_Get(arg1);
4293
4294 wxPyEndAllowThreads(__tstate);
4295 if (PyErr_Occurred()) SWIG_fail;
4296 }
4297 resultobj = result;
4298 return resultobj;
4299 fail:
4300 return NULL;
4301 }
4302
4303
4304 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4305 PyObject *obj;
4306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4307 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4308 Py_INCREF(obj);
4309 return Py_BuildValue((char *)"");
4310 }
4311 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4312 PyObject *resultobj;
4313 wxPoint *arg1 = (wxPoint *) 0 ;
4314 int arg2 ;
4315 PyObject * obj0 = 0 ;
4316 PyObject * obj1 = 0 ;
4317 char *kwnames[] = {
4318 (char *) "self",(char *) "x", NULL
4319 };
4320
4321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4323 if (SWIG_arg_fail(1)) SWIG_fail;
4324 {
4325 arg2 = (int)(SWIG_As_int(obj1));
4326 if (SWIG_arg_fail(2)) SWIG_fail;
4327 }
4328 if (arg1) (arg1)->x = arg2;
4329
4330 Py_INCREF(Py_None); resultobj = Py_None;
4331 return resultobj;
4332 fail:
4333 return NULL;
4334 }
4335
4336
4337 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj;
4339 wxPoint *arg1 = (wxPoint *) 0 ;
4340 int result;
4341 PyObject * obj0 = 0 ;
4342 char *kwnames[] = {
4343 (char *) "self", NULL
4344 };
4345
4346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4348 if (SWIG_arg_fail(1)) SWIG_fail;
4349 result = (int) ((arg1)->x);
4350
4351 {
4352 resultobj = SWIG_From_int((int)(result));
4353 }
4354 return resultobj;
4355 fail:
4356 return NULL;
4357 }
4358
4359
4360 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4361 PyObject *resultobj;
4362 wxPoint *arg1 = (wxPoint *) 0 ;
4363 int arg2 ;
4364 PyObject * obj0 = 0 ;
4365 PyObject * obj1 = 0 ;
4366 char *kwnames[] = {
4367 (char *) "self",(char *) "y", NULL
4368 };
4369
4370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4372 if (SWIG_arg_fail(1)) SWIG_fail;
4373 {
4374 arg2 = (int)(SWIG_As_int(obj1));
4375 if (SWIG_arg_fail(2)) SWIG_fail;
4376 }
4377 if (arg1) (arg1)->y = arg2;
4378
4379 Py_INCREF(Py_None); resultobj = Py_None;
4380 return resultobj;
4381 fail:
4382 return NULL;
4383 }
4384
4385
4386 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4387 PyObject *resultobj;
4388 wxPoint *arg1 = (wxPoint *) 0 ;
4389 int result;
4390 PyObject * obj0 = 0 ;
4391 char *kwnames[] = {
4392 (char *) "self", NULL
4393 };
4394
4395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4397 if (SWIG_arg_fail(1)) SWIG_fail;
4398 result = (int) ((arg1)->y);
4399
4400 {
4401 resultobj = SWIG_From_int((int)(result));
4402 }
4403 return resultobj;
4404 fail:
4405 return NULL;
4406 }
4407
4408
4409 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4410 PyObject *resultobj;
4411 int arg1 = (int) 0 ;
4412 int arg2 = (int) 0 ;
4413 wxPoint *result;
4414 PyObject * obj0 = 0 ;
4415 PyObject * obj1 = 0 ;
4416 char *kwnames[] = {
4417 (char *) "x",(char *) "y", NULL
4418 };
4419
4420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4421 if (obj0) {
4422 {
4423 arg1 = (int)(SWIG_As_int(obj0));
4424 if (SWIG_arg_fail(1)) SWIG_fail;
4425 }
4426 }
4427 if (obj1) {
4428 {
4429 arg2 = (int)(SWIG_As_int(obj1));
4430 if (SWIG_arg_fail(2)) SWIG_fail;
4431 }
4432 }
4433 {
4434 PyThreadState* __tstate = wxPyBeginAllowThreads();
4435 result = (wxPoint *)new wxPoint(arg1,arg2);
4436
4437 wxPyEndAllowThreads(__tstate);
4438 if (PyErr_Occurred()) SWIG_fail;
4439 }
4440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4448 PyObject *resultobj;
4449 wxPoint *arg1 = (wxPoint *) 0 ;
4450 PyObject * obj0 = 0 ;
4451 char *kwnames[] = {
4452 (char *) "self", NULL
4453 };
4454
4455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4457 if (SWIG_arg_fail(1)) SWIG_fail;
4458 {
4459 PyThreadState* __tstate = wxPyBeginAllowThreads();
4460 delete arg1;
4461
4462 wxPyEndAllowThreads(__tstate);
4463 if (PyErr_Occurred()) SWIG_fail;
4464 }
4465 Py_INCREF(Py_None); resultobj = Py_None;
4466 return resultobj;
4467 fail:
4468 return NULL;
4469 }
4470
4471
4472 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4473 PyObject *resultobj;
4474 wxPoint *arg1 = (wxPoint *) 0 ;
4475 wxPoint *arg2 = 0 ;
4476 bool result;
4477 wxPoint temp2 ;
4478 PyObject * obj0 = 0 ;
4479 PyObject * obj1 = 0 ;
4480 char *kwnames[] = {
4481 (char *) "self",(char *) "pt", NULL
4482 };
4483
4484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4486 if (SWIG_arg_fail(1)) SWIG_fail;
4487 {
4488 arg2 = &temp2;
4489 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4490 }
4491 {
4492 PyThreadState* __tstate = wxPyBeginAllowThreads();
4493 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4494
4495 wxPyEndAllowThreads(__tstate);
4496 if (PyErr_Occurred()) SWIG_fail;
4497 }
4498 {
4499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4500 }
4501 return resultobj;
4502 fail:
4503 return NULL;
4504 }
4505
4506
4507 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj;
4509 wxPoint *arg1 = (wxPoint *) 0 ;
4510 wxPoint *arg2 = 0 ;
4511 bool result;
4512 wxPoint temp2 ;
4513 PyObject * obj0 = 0 ;
4514 PyObject * obj1 = 0 ;
4515 char *kwnames[] = {
4516 (char *) "self",(char *) "pt", NULL
4517 };
4518
4519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4521 if (SWIG_arg_fail(1)) SWIG_fail;
4522 {
4523 arg2 = &temp2;
4524 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4525 }
4526 {
4527 PyThreadState* __tstate = wxPyBeginAllowThreads();
4528 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4529
4530 wxPyEndAllowThreads(__tstate);
4531 if (PyErr_Occurred()) SWIG_fail;
4532 }
4533 {
4534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4535 }
4536 return resultobj;
4537 fail:
4538 return NULL;
4539 }
4540
4541
4542 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4543 PyObject *resultobj;
4544 wxPoint *arg1 = (wxPoint *) 0 ;
4545 wxPoint *arg2 = 0 ;
4546 wxPoint result;
4547 wxPoint temp2 ;
4548 PyObject * obj0 = 0 ;
4549 PyObject * obj1 = 0 ;
4550 char *kwnames[] = {
4551 (char *) "self",(char *) "pt", NULL
4552 };
4553
4554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4556 if (SWIG_arg_fail(1)) SWIG_fail;
4557 {
4558 arg2 = &temp2;
4559 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4560 }
4561 {
4562 PyThreadState* __tstate = wxPyBeginAllowThreads();
4563 result = (arg1)->operator +((wxPoint const &)*arg2);
4564
4565 wxPyEndAllowThreads(__tstate);
4566 if (PyErr_Occurred()) SWIG_fail;
4567 }
4568 {
4569 wxPoint * resultptr;
4570 resultptr = new wxPoint((wxPoint &)(result));
4571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4572 }
4573 return resultobj;
4574 fail:
4575 return NULL;
4576 }
4577
4578
4579 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4580 PyObject *resultobj;
4581 wxPoint *arg1 = (wxPoint *) 0 ;
4582 wxPoint *arg2 = 0 ;
4583 wxPoint result;
4584 wxPoint temp2 ;
4585 PyObject * obj0 = 0 ;
4586 PyObject * obj1 = 0 ;
4587 char *kwnames[] = {
4588 (char *) "self",(char *) "pt", NULL
4589 };
4590
4591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4593 if (SWIG_arg_fail(1)) SWIG_fail;
4594 {
4595 arg2 = &temp2;
4596 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4597 }
4598 {
4599 PyThreadState* __tstate = wxPyBeginAllowThreads();
4600 result = (arg1)->operator -((wxPoint const &)*arg2);
4601
4602 wxPyEndAllowThreads(__tstate);
4603 if (PyErr_Occurred()) SWIG_fail;
4604 }
4605 {
4606 wxPoint * resultptr;
4607 resultptr = new wxPoint((wxPoint &)(result));
4608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4609 }
4610 return resultobj;
4611 fail:
4612 return NULL;
4613 }
4614
4615
4616 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4617 PyObject *resultobj;
4618 wxPoint *arg1 = (wxPoint *) 0 ;
4619 wxPoint *arg2 = 0 ;
4620 wxPoint *result;
4621 wxPoint temp2 ;
4622 PyObject * obj0 = 0 ;
4623 PyObject * obj1 = 0 ;
4624 char *kwnames[] = {
4625 (char *) "self",(char *) "pt", NULL
4626 };
4627
4628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4630 if (SWIG_arg_fail(1)) SWIG_fail;
4631 {
4632 arg2 = &temp2;
4633 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4634 }
4635 {
4636 PyThreadState* __tstate = wxPyBeginAllowThreads();
4637 {
4638 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4639 result = (wxPoint *) &_result_ref;
4640 }
4641
4642 wxPyEndAllowThreads(__tstate);
4643 if (PyErr_Occurred()) SWIG_fail;
4644 }
4645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4653 PyObject *resultobj;
4654 wxPoint *arg1 = (wxPoint *) 0 ;
4655 wxPoint *arg2 = 0 ;
4656 wxPoint *result;
4657 wxPoint temp2 ;
4658 PyObject * obj0 = 0 ;
4659 PyObject * obj1 = 0 ;
4660 char *kwnames[] = {
4661 (char *) "self",(char *) "pt", NULL
4662 };
4663
4664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4666 if (SWIG_arg_fail(1)) SWIG_fail;
4667 {
4668 arg2 = &temp2;
4669 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4670 }
4671 {
4672 PyThreadState* __tstate = wxPyBeginAllowThreads();
4673 {
4674 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4675 result = (wxPoint *) &_result_ref;
4676 }
4677
4678 wxPyEndAllowThreads(__tstate);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4682 return resultobj;
4683 fail:
4684 return NULL;
4685 }
4686
4687
4688 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4689 PyObject *resultobj;
4690 wxPoint *arg1 = (wxPoint *) 0 ;
4691 long arg2 ;
4692 long arg3 ;
4693 PyObject * obj0 = 0 ;
4694 PyObject * obj1 = 0 ;
4695 PyObject * obj2 = 0 ;
4696 char *kwnames[] = {
4697 (char *) "self",(char *) "x",(char *) "y", NULL
4698 };
4699
4700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4702 if (SWIG_arg_fail(1)) SWIG_fail;
4703 {
4704 arg2 = (long)(SWIG_As_long(obj1));
4705 if (SWIG_arg_fail(2)) SWIG_fail;
4706 }
4707 {
4708 arg3 = (long)(SWIG_As_long(obj2));
4709 if (SWIG_arg_fail(3)) SWIG_fail;
4710 }
4711 {
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 wxPoint_Set(arg1,arg2,arg3);
4714
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 Py_INCREF(Py_None); resultobj = Py_None;
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj;
4727 wxPoint *arg1 = (wxPoint *) 0 ;
4728 PyObject *result;
4729 PyObject * obj0 = 0 ;
4730 char *kwnames[] = {
4731 (char *) "self", NULL
4732 };
4733
4734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4736 if (SWIG_arg_fail(1)) SWIG_fail;
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 result = (PyObject *)wxPoint_Get(arg1);
4740
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 resultobj = result;
4745 return resultobj;
4746 fail:
4747 return NULL;
4748 }
4749
4750
4751 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4752 PyObject *obj;
4753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4754 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4755 Py_INCREF(obj);
4756 return Py_BuildValue((char *)"");
4757 }
4758 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4759 PyObject *resultobj;
4760 int arg1 = (int) 0 ;
4761 int arg2 = (int) 0 ;
4762 int arg3 = (int) 0 ;
4763 int arg4 = (int) 0 ;
4764 wxRect *result;
4765 PyObject * obj0 = 0 ;
4766 PyObject * obj1 = 0 ;
4767 PyObject * obj2 = 0 ;
4768 PyObject * obj3 = 0 ;
4769 char *kwnames[] = {
4770 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4771 };
4772
4773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4774 if (obj0) {
4775 {
4776 arg1 = (int)(SWIG_As_int(obj0));
4777 if (SWIG_arg_fail(1)) SWIG_fail;
4778 }
4779 }
4780 if (obj1) {
4781 {
4782 arg2 = (int)(SWIG_As_int(obj1));
4783 if (SWIG_arg_fail(2)) SWIG_fail;
4784 }
4785 }
4786 if (obj2) {
4787 {
4788 arg3 = (int)(SWIG_As_int(obj2));
4789 if (SWIG_arg_fail(3)) SWIG_fail;
4790 }
4791 }
4792 if (obj3) {
4793 {
4794 arg4 = (int)(SWIG_As_int(obj3));
4795 if (SWIG_arg_fail(4)) SWIG_fail;
4796 }
4797 }
4798 {
4799 PyThreadState* __tstate = wxPyBeginAllowThreads();
4800 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4801
4802 wxPyEndAllowThreads(__tstate);
4803 if (PyErr_Occurred()) SWIG_fail;
4804 }
4805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4806 return resultobj;
4807 fail:
4808 return NULL;
4809 }
4810
4811
4812 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4813 PyObject *resultobj;
4814 wxPoint *arg1 = 0 ;
4815 wxPoint *arg2 = 0 ;
4816 wxRect *result;
4817 wxPoint temp1 ;
4818 wxPoint temp2 ;
4819 PyObject * obj0 = 0 ;
4820 PyObject * obj1 = 0 ;
4821 char *kwnames[] = {
4822 (char *) "topLeft",(char *) "bottomRight", NULL
4823 };
4824
4825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4826 {
4827 arg1 = &temp1;
4828 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4829 }
4830 {
4831 arg2 = &temp2;
4832 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4833 }
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4837
4838 wxPyEndAllowThreads(__tstate);
4839 if (PyErr_Occurred()) SWIG_fail;
4840 }
4841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj;
4850 wxPoint *arg1 = 0 ;
4851 wxSize *arg2 = 0 ;
4852 wxRect *result;
4853 wxPoint temp1 ;
4854 wxSize temp2 ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 char *kwnames[] = {
4858 (char *) "pos",(char *) "size", NULL
4859 };
4860
4861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4862 {
4863 arg1 = &temp1;
4864 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4865 }
4866 {
4867 arg2 = &temp2;
4868 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4869 }
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4873
4874 wxPyEndAllowThreads(__tstate);
4875 if (PyErr_Occurred()) SWIG_fail;
4876 }
4877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4878 return resultobj;
4879 fail:
4880 return NULL;
4881 }
4882
4883
4884 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4885 PyObject *resultobj;
4886 wxSize *arg1 = 0 ;
4887 wxRect *result;
4888 wxSize temp1 ;
4889 PyObject * obj0 = 0 ;
4890 char *kwnames[] = {
4891 (char *) "size", NULL
4892 };
4893
4894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4895 {
4896 arg1 = &temp1;
4897 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4898 }
4899 {
4900 PyThreadState* __tstate = wxPyBeginAllowThreads();
4901 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4902
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4914 PyObject *resultobj;
4915 wxRect *arg1 = (wxRect *) 0 ;
4916 PyObject * obj0 = 0 ;
4917 char *kwnames[] = {
4918 (char *) "self", NULL
4919 };
4920
4921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4923 if (SWIG_arg_fail(1)) SWIG_fail;
4924 {
4925 PyThreadState* __tstate = wxPyBeginAllowThreads();
4926 delete arg1;
4927
4928 wxPyEndAllowThreads(__tstate);
4929 if (PyErr_Occurred()) SWIG_fail;
4930 }
4931 Py_INCREF(Py_None); resultobj = Py_None;
4932 return resultobj;
4933 fail:
4934 return NULL;
4935 }
4936
4937
4938 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4939 PyObject *resultobj;
4940 wxRect *arg1 = (wxRect *) 0 ;
4941 int result;
4942 PyObject * obj0 = 0 ;
4943 char *kwnames[] = {
4944 (char *) "self", NULL
4945 };
4946
4947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4949 if (SWIG_arg_fail(1)) SWIG_fail;
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 result = (int)((wxRect const *)arg1)->GetX();
4953
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 {
4958 resultobj = SWIG_From_int((int)(result));
4959 }
4960 return resultobj;
4961 fail:
4962 return NULL;
4963 }
4964
4965
4966 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj;
4968 wxRect *arg1 = (wxRect *) 0 ;
4969 int arg2 ;
4970 PyObject * obj0 = 0 ;
4971 PyObject * obj1 = 0 ;
4972 char *kwnames[] = {
4973 (char *) "self",(char *) "x", NULL
4974 };
4975
4976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4978 if (SWIG_arg_fail(1)) SWIG_fail;
4979 {
4980 arg2 = (int)(SWIG_As_int(obj1));
4981 if (SWIG_arg_fail(2)) SWIG_fail;
4982 }
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 (arg1)->SetX(arg2);
4986
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 Py_INCREF(Py_None); resultobj = Py_None;
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4998 PyObject *resultobj;
4999 wxRect *arg1 = (wxRect *) 0 ;
5000 int result;
5001 PyObject * obj0 = 0 ;
5002 char *kwnames[] = {
5003 (char *) "self", NULL
5004 };
5005
5006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5008 if (SWIG_arg_fail(1)) SWIG_fail;
5009 {
5010 PyThreadState* __tstate = wxPyBeginAllowThreads();
5011 result = (int)(arg1)->GetY();
5012
5013 wxPyEndAllowThreads(__tstate);
5014 if (PyErr_Occurred()) SWIG_fail;
5015 }
5016 {
5017 resultobj = SWIG_From_int((int)(result));
5018 }
5019 return resultobj;
5020 fail:
5021 return NULL;
5022 }
5023
5024
5025 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5026 PyObject *resultobj;
5027 wxRect *arg1 = (wxRect *) 0 ;
5028 int arg2 ;
5029 PyObject * obj0 = 0 ;
5030 PyObject * obj1 = 0 ;
5031 char *kwnames[] = {
5032 (char *) "self",(char *) "y", NULL
5033 };
5034
5035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5037 if (SWIG_arg_fail(1)) SWIG_fail;
5038 {
5039 arg2 = (int)(SWIG_As_int(obj1));
5040 if (SWIG_arg_fail(2)) SWIG_fail;
5041 }
5042 {
5043 PyThreadState* __tstate = wxPyBeginAllowThreads();
5044 (arg1)->SetY(arg2);
5045
5046 wxPyEndAllowThreads(__tstate);
5047 if (PyErr_Occurred()) SWIG_fail;
5048 }
5049 Py_INCREF(Py_None); resultobj = Py_None;
5050 return resultobj;
5051 fail:
5052 return NULL;
5053 }
5054
5055
5056 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5057 PyObject *resultobj;
5058 wxRect *arg1 = (wxRect *) 0 ;
5059 int result;
5060 PyObject * obj0 = 0 ;
5061 char *kwnames[] = {
5062 (char *) "self", NULL
5063 };
5064
5065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5067 if (SWIG_arg_fail(1)) SWIG_fail;
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 result = (int)((wxRect const *)arg1)->GetWidth();
5071
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 {
5076 resultobj = SWIG_From_int((int)(result));
5077 }
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5085 PyObject *resultobj;
5086 wxRect *arg1 = (wxRect *) 0 ;
5087 int arg2 ;
5088 PyObject * obj0 = 0 ;
5089 PyObject * obj1 = 0 ;
5090 char *kwnames[] = {
5091 (char *) "self",(char *) "w", NULL
5092 };
5093
5094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5096 if (SWIG_arg_fail(1)) SWIG_fail;
5097 {
5098 arg2 = (int)(SWIG_As_int(obj1));
5099 if (SWIG_arg_fail(2)) SWIG_fail;
5100 }
5101 {
5102 PyThreadState* __tstate = wxPyBeginAllowThreads();
5103 (arg1)->SetWidth(arg2);
5104
5105 wxPyEndAllowThreads(__tstate);
5106 if (PyErr_Occurred()) SWIG_fail;
5107 }
5108 Py_INCREF(Py_None); resultobj = Py_None;
5109 return resultobj;
5110 fail:
5111 return NULL;
5112 }
5113
5114
5115 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5116 PyObject *resultobj;
5117 wxRect *arg1 = (wxRect *) 0 ;
5118 int result;
5119 PyObject * obj0 = 0 ;
5120 char *kwnames[] = {
5121 (char *) "self", NULL
5122 };
5123
5124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5126 if (SWIG_arg_fail(1)) SWIG_fail;
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 result = (int)((wxRect const *)arg1)->GetHeight();
5130
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 {
5135 resultobj = SWIG_From_int((int)(result));
5136 }
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj;
5145 wxRect *arg1 = (wxRect *) 0 ;
5146 int arg2 ;
5147 PyObject * obj0 = 0 ;
5148 PyObject * obj1 = 0 ;
5149 char *kwnames[] = {
5150 (char *) "self",(char *) "h", NULL
5151 };
5152
5153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5155 if (SWIG_arg_fail(1)) SWIG_fail;
5156 {
5157 arg2 = (int)(SWIG_As_int(obj1));
5158 if (SWIG_arg_fail(2)) SWIG_fail;
5159 }
5160 {
5161 PyThreadState* __tstate = wxPyBeginAllowThreads();
5162 (arg1)->SetHeight(arg2);
5163
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 Py_INCREF(Py_None); resultobj = Py_None;
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5175 PyObject *resultobj;
5176 wxRect *arg1 = (wxRect *) 0 ;
5177 wxPoint result;
5178 PyObject * obj0 = 0 ;
5179 char *kwnames[] = {
5180 (char *) "self", NULL
5181 };
5182
5183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5185 if (SWIG_arg_fail(1)) SWIG_fail;
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 result = ((wxRect const *)arg1)->GetPosition();
5189
5190 wxPyEndAllowThreads(__tstate);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 {
5194 wxPoint * resultptr;
5195 resultptr = new wxPoint((wxPoint &)(result));
5196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5197 }
5198 return resultobj;
5199 fail:
5200 return NULL;
5201 }
5202
5203
5204 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5205 PyObject *resultobj;
5206 wxRect *arg1 = (wxRect *) 0 ;
5207 wxPoint *arg2 = 0 ;
5208 wxPoint temp2 ;
5209 PyObject * obj0 = 0 ;
5210 PyObject * obj1 = 0 ;
5211 char *kwnames[] = {
5212 (char *) "self",(char *) "p", NULL
5213 };
5214
5215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5217 if (SWIG_arg_fail(1)) SWIG_fail;
5218 {
5219 arg2 = &temp2;
5220 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5221 }
5222 {
5223 PyThreadState* __tstate = wxPyBeginAllowThreads();
5224 (arg1)->SetPosition((wxPoint const &)*arg2);
5225
5226 wxPyEndAllowThreads(__tstate);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 Py_INCREF(Py_None); resultobj = Py_None;
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj;
5238 wxRect *arg1 = (wxRect *) 0 ;
5239 wxSize result;
5240 PyObject * obj0 = 0 ;
5241 char *kwnames[] = {
5242 (char *) "self", NULL
5243 };
5244
5245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5247 if (SWIG_arg_fail(1)) SWIG_fail;
5248 {
5249 PyThreadState* __tstate = wxPyBeginAllowThreads();
5250 result = ((wxRect const *)arg1)->GetSize();
5251
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 {
5256 wxSize * resultptr;
5257 resultptr = new wxSize((wxSize &)(result));
5258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5259 }
5260 return resultobj;
5261 fail:
5262 return NULL;
5263 }
5264
5265
5266 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5267 PyObject *resultobj;
5268 wxRect *arg1 = (wxRect *) 0 ;
5269 wxSize *arg2 = 0 ;
5270 wxSize temp2 ;
5271 PyObject * obj0 = 0 ;
5272 PyObject * obj1 = 0 ;
5273 char *kwnames[] = {
5274 (char *) "self",(char *) "s", NULL
5275 };
5276
5277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5279 if (SWIG_arg_fail(1)) SWIG_fail;
5280 {
5281 arg2 = &temp2;
5282 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5283 }
5284 {
5285 PyThreadState* __tstate = wxPyBeginAllowThreads();
5286 (arg1)->SetSize((wxSize const &)*arg2);
5287
5288 wxPyEndAllowThreads(__tstate);
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 Py_INCREF(Py_None); resultobj = Py_None;
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj;
5300 wxRect *arg1 = (wxRect *) 0 ;
5301 bool result;
5302 PyObject * obj0 = 0 ;
5303 char *kwnames[] = {
5304 (char *) "self", NULL
5305 };
5306
5307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5309 if (SWIG_arg_fail(1)) SWIG_fail;
5310 {
5311 PyThreadState* __tstate = wxPyBeginAllowThreads();
5312 result = (bool)((wxRect const *)arg1)->IsEmpty();
5313
5314 wxPyEndAllowThreads(__tstate);
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 {
5318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5319 }
5320 return resultobj;
5321 fail:
5322 return NULL;
5323 }
5324
5325
5326 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5327 PyObject *resultobj;
5328 wxRect *arg1 = (wxRect *) 0 ;
5329 wxPoint result;
5330 PyObject * obj0 = 0 ;
5331 char *kwnames[] = {
5332 (char *) "self", NULL
5333 };
5334
5335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5337 if (SWIG_arg_fail(1)) SWIG_fail;
5338 {
5339 PyThreadState* __tstate = wxPyBeginAllowThreads();
5340 result = ((wxRect const *)arg1)->GetTopLeft();
5341
5342 wxPyEndAllowThreads(__tstate);
5343 if (PyErr_Occurred()) SWIG_fail;
5344 }
5345 {
5346 wxPoint * resultptr;
5347 resultptr = new wxPoint((wxPoint &)(result));
5348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5349 }
5350 return resultobj;
5351 fail:
5352 return NULL;
5353 }
5354
5355
5356 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5357 PyObject *resultobj;
5358 wxRect *arg1 = (wxRect *) 0 ;
5359 wxPoint *arg2 = 0 ;
5360 wxPoint temp2 ;
5361 PyObject * obj0 = 0 ;
5362 PyObject * obj1 = 0 ;
5363 char *kwnames[] = {
5364 (char *) "self",(char *) "p", NULL
5365 };
5366
5367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5369 if (SWIG_arg_fail(1)) SWIG_fail;
5370 {
5371 arg2 = &temp2;
5372 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5373 }
5374 {
5375 PyThreadState* __tstate = wxPyBeginAllowThreads();
5376 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5377
5378 wxPyEndAllowThreads(__tstate);
5379 if (PyErr_Occurred()) SWIG_fail;
5380 }
5381 Py_INCREF(Py_None); resultobj = Py_None;
5382 return resultobj;
5383 fail:
5384 return NULL;
5385 }
5386
5387
5388 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5389 PyObject *resultobj;
5390 wxRect *arg1 = (wxRect *) 0 ;
5391 wxPoint result;
5392 PyObject * obj0 = 0 ;
5393 char *kwnames[] = {
5394 (char *) "self", NULL
5395 };
5396
5397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5399 if (SWIG_arg_fail(1)) SWIG_fail;
5400 {
5401 PyThreadState* __tstate = wxPyBeginAllowThreads();
5402 result = ((wxRect const *)arg1)->GetBottomRight();
5403
5404 wxPyEndAllowThreads(__tstate);
5405 if (PyErr_Occurred()) SWIG_fail;
5406 }
5407 {
5408 wxPoint * resultptr;
5409 resultptr = new wxPoint((wxPoint &)(result));
5410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5411 }
5412 return resultobj;
5413 fail:
5414 return NULL;
5415 }
5416
5417
5418 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5419 PyObject *resultobj;
5420 wxRect *arg1 = (wxRect *) 0 ;
5421 wxPoint *arg2 = 0 ;
5422 wxPoint temp2 ;
5423 PyObject * obj0 = 0 ;
5424 PyObject * obj1 = 0 ;
5425 char *kwnames[] = {
5426 (char *) "self",(char *) "p", NULL
5427 };
5428
5429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5431 if (SWIG_arg_fail(1)) SWIG_fail;
5432 {
5433 arg2 = &temp2;
5434 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5435 }
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5439
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 Py_INCREF(Py_None); resultobj = Py_None;
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5451 PyObject *resultobj;
5452 wxRect *arg1 = (wxRect *) 0 ;
5453 int result;
5454 PyObject * obj0 = 0 ;
5455 char *kwnames[] = {
5456 (char *) "self", NULL
5457 };
5458
5459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5461 if (SWIG_arg_fail(1)) SWIG_fail;
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 result = (int)((wxRect const *)arg1)->GetLeft();
5465
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 {
5470 resultobj = SWIG_From_int((int)(result));
5471 }
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5479 PyObject *resultobj;
5480 wxRect *arg1 = (wxRect *) 0 ;
5481 int result;
5482 PyObject * obj0 = 0 ;
5483 char *kwnames[] = {
5484 (char *) "self", NULL
5485 };
5486
5487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5489 if (SWIG_arg_fail(1)) SWIG_fail;
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 result = (int)((wxRect const *)arg1)->GetTop();
5493
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 {
5498 resultobj = SWIG_From_int((int)(result));
5499 }
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj;
5508 wxRect *arg1 = (wxRect *) 0 ;
5509 int result;
5510 PyObject * obj0 = 0 ;
5511 char *kwnames[] = {
5512 (char *) "self", NULL
5513 };
5514
5515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5517 if (SWIG_arg_fail(1)) SWIG_fail;
5518 {
5519 PyThreadState* __tstate = wxPyBeginAllowThreads();
5520 result = (int)((wxRect const *)arg1)->GetBottom();
5521
5522 wxPyEndAllowThreads(__tstate);
5523 if (PyErr_Occurred()) SWIG_fail;
5524 }
5525 {
5526 resultobj = SWIG_From_int((int)(result));
5527 }
5528 return resultobj;
5529 fail:
5530 return NULL;
5531 }
5532
5533
5534 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5535 PyObject *resultobj;
5536 wxRect *arg1 = (wxRect *) 0 ;
5537 int result;
5538 PyObject * obj0 = 0 ;
5539 char *kwnames[] = {
5540 (char *) "self", NULL
5541 };
5542
5543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5545 if (SWIG_arg_fail(1)) SWIG_fail;
5546 {
5547 PyThreadState* __tstate = wxPyBeginAllowThreads();
5548 result = (int)((wxRect const *)arg1)->GetRight();
5549
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 {
5554 resultobj = SWIG_From_int((int)(result));
5555 }
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj;
5564 wxRect *arg1 = (wxRect *) 0 ;
5565 int arg2 ;
5566 PyObject * obj0 = 0 ;
5567 PyObject * obj1 = 0 ;
5568 char *kwnames[] = {
5569 (char *) "self",(char *) "left", NULL
5570 };
5571
5572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5574 if (SWIG_arg_fail(1)) SWIG_fail;
5575 {
5576 arg2 = (int)(SWIG_As_int(obj1));
5577 if (SWIG_arg_fail(2)) SWIG_fail;
5578 }
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 (arg1)->SetLeft(arg2);
5582
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 Py_INCREF(Py_None); resultobj = Py_None;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5594 PyObject *resultobj;
5595 wxRect *arg1 = (wxRect *) 0 ;
5596 int arg2 ;
5597 PyObject * obj0 = 0 ;
5598 PyObject * obj1 = 0 ;
5599 char *kwnames[] = {
5600 (char *) "self",(char *) "right", NULL
5601 };
5602
5603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5605 if (SWIG_arg_fail(1)) SWIG_fail;
5606 {
5607 arg2 = (int)(SWIG_As_int(obj1));
5608 if (SWIG_arg_fail(2)) SWIG_fail;
5609 }
5610 {
5611 PyThreadState* __tstate = wxPyBeginAllowThreads();
5612 (arg1)->SetRight(arg2);
5613
5614 wxPyEndAllowThreads(__tstate);
5615 if (PyErr_Occurred()) SWIG_fail;
5616 }
5617 Py_INCREF(Py_None); resultobj = Py_None;
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj;
5626 wxRect *arg1 = (wxRect *) 0 ;
5627 int arg2 ;
5628 PyObject * obj0 = 0 ;
5629 PyObject * obj1 = 0 ;
5630 char *kwnames[] = {
5631 (char *) "self",(char *) "top", NULL
5632 };
5633
5634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5636 if (SWIG_arg_fail(1)) SWIG_fail;
5637 {
5638 arg2 = (int)(SWIG_As_int(obj1));
5639 if (SWIG_arg_fail(2)) SWIG_fail;
5640 }
5641 {
5642 PyThreadState* __tstate = wxPyBeginAllowThreads();
5643 (arg1)->SetTop(arg2);
5644
5645 wxPyEndAllowThreads(__tstate);
5646 if (PyErr_Occurred()) SWIG_fail;
5647 }
5648 Py_INCREF(Py_None); resultobj = Py_None;
5649 return resultobj;
5650 fail:
5651 return NULL;
5652 }
5653
5654
5655 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5656 PyObject *resultobj;
5657 wxRect *arg1 = (wxRect *) 0 ;
5658 int arg2 ;
5659 PyObject * obj0 = 0 ;
5660 PyObject * obj1 = 0 ;
5661 char *kwnames[] = {
5662 (char *) "self",(char *) "bottom", NULL
5663 };
5664
5665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5667 if (SWIG_arg_fail(1)) SWIG_fail;
5668 {
5669 arg2 = (int)(SWIG_As_int(obj1));
5670 if (SWIG_arg_fail(2)) SWIG_fail;
5671 }
5672 {
5673 PyThreadState* __tstate = wxPyBeginAllowThreads();
5674 (arg1)->SetBottom(arg2);
5675
5676 wxPyEndAllowThreads(__tstate);
5677 if (PyErr_Occurred()) SWIG_fail;
5678 }
5679 Py_INCREF(Py_None); resultobj = Py_None;
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5687 PyObject *resultobj;
5688 wxRect *arg1 = (wxRect *) 0 ;
5689 int arg2 ;
5690 int arg3 ;
5691 wxRect *result;
5692 PyObject * obj0 = 0 ;
5693 PyObject * obj1 = 0 ;
5694 PyObject * obj2 = 0 ;
5695 char *kwnames[] = {
5696 (char *) "self",(char *) "dx",(char *) "dy", NULL
5697 };
5698
5699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5701 if (SWIG_arg_fail(1)) SWIG_fail;
5702 {
5703 arg2 = (int)(SWIG_As_int(obj1));
5704 if (SWIG_arg_fail(2)) SWIG_fail;
5705 }
5706 {
5707 arg3 = (int)(SWIG_As_int(obj2));
5708 if (SWIG_arg_fail(3)) SWIG_fail;
5709 }
5710 {
5711 PyThreadState* __tstate = wxPyBeginAllowThreads();
5712 {
5713 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5714 result = (wxRect *) &_result_ref;
5715 }
5716
5717 wxPyEndAllowThreads(__tstate);
5718 if (PyErr_Occurred()) SWIG_fail;
5719 }
5720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5721 return resultobj;
5722 fail:
5723 return NULL;
5724 }
5725
5726
5727 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5728 PyObject *resultobj;
5729 wxRect *arg1 = (wxRect *) 0 ;
5730 int arg2 ;
5731 int arg3 ;
5732 wxRect *result;
5733 PyObject * obj0 = 0 ;
5734 PyObject * obj1 = 0 ;
5735 PyObject * obj2 = 0 ;
5736 char *kwnames[] = {
5737 (char *) "self",(char *) "dx",(char *) "dy", NULL
5738 };
5739
5740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5742 if (SWIG_arg_fail(1)) SWIG_fail;
5743 {
5744 arg2 = (int)(SWIG_As_int(obj1));
5745 if (SWIG_arg_fail(2)) SWIG_fail;
5746 }
5747 {
5748 arg3 = (int)(SWIG_As_int(obj2));
5749 if (SWIG_arg_fail(3)) SWIG_fail;
5750 }
5751 {
5752 PyThreadState* __tstate = wxPyBeginAllowThreads();
5753 {
5754 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5755 result = (wxRect *) &_result_ref;
5756 }
5757
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5762 return resultobj;
5763 fail:
5764 return NULL;
5765 }
5766
5767
5768 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj;
5770 wxRect *arg1 = (wxRect *) 0 ;
5771 int arg2 ;
5772 int arg3 ;
5773 PyObject * obj0 = 0 ;
5774 PyObject * obj1 = 0 ;
5775 PyObject * obj2 = 0 ;
5776 char *kwnames[] = {
5777 (char *) "self",(char *) "dx",(char *) "dy", NULL
5778 };
5779
5780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5782 if (SWIG_arg_fail(1)) SWIG_fail;
5783 {
5784 arg2 = (int)(SWIG_As_int(obj1));
5785 if (SWIG_arg_fail(2)) SWIG_fail;
5786 }
5787 {
5788 arg3 = (int)(SWIG_As_int(obj2));
5789 if (SWIG_arg_fail(3)) SWIG_fail;
5790 }
5791 {
5792 PyThreadState* __tstate = wxPyBeginAllowThreads();
5793 (arg1)->Offset(arg2,arg3);
5794
5795 wxPyEndAllowThreads(__tstate);
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 Py_INCREF(Py_None); resultobj = Py_None;
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj;
5807 wxRect *arg1 = (wxRect *) 0 ;
5808 wxPoint *arg2 = 0 ;
5809 wxPoint temp2 ;
5810 PyObject * obj0 = 0 ;
5811 PyObject * obj1 = 0 ;
5812 char *kwnames[] = {
5813 (char *) "self",(char *) "pt", NULL
5814 };
5815
5816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5818 if (SWIG_arg_fail(1)) SWIG_fail;
5819 {
5820 arg2 = &temp2;
5821 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5822 }
5823 {
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 (arg1)->Offset((wxPoint const &)*arg2);
5826
5827 wxPyEndAllowThreads(__tstate);
5828 if (PyErr_Occurred()) SWIG_fail;
5829 }
5830 Py_INCREF(Py_None); resultobj = Py_None;
5831 return resultobj;
5832 fail:
5833 return NULL;
5834 }
5835
5836
5837 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5838 PyObject *resultobj;
5839 wxRect *arg1 = (wxRect *) 0 ;
5840 wxRect *arg2 = 0 ;
5841 wxRect result;
5842 wxRect temp2 ;
5843 PyObject * obj0 = 0 ;
5844 PyObject * obj1 = 0 ;
5845 char *kwnames[] = {
5846 (char *) "self",(char *) "rect", NULL
5847 };
5848
5849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5851 if (SWIG_arg_fail(1)) SWIG_fail;
5852 {
5853 arg2 = &temp2;
5854 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5855 }
5856 {
5857 PyThreadState* __tstate = wxPyBeginAllowThreads();
5858 result = (arg1)->Intersect((wxRect const &)*arg2);
5859
5860 wxPyEndAllowThreads(__tstate);
5861 if (PyErr_Occurred()) SWIG_fail;
5862 }
5863 {
5864 wxRect * resultptr;
5865 resultptr = new wxRect((wxRect &)(result));
5866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5867 }
5868 return resultobj;
5869 fail:
5870 return NULL;
5871 }
5872
5873
5874 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj;
5876 wxRect *arg1 = (wxRect *) 0 ;
5877 wxRect *arg2 = 0 ;
5878 wxRect result;
5879 wxRect temp2 ;
5880 PyObject * obj0 = 0 ;
5881 PyObject * obj1 = 0 ;
5882 char *kwnames[] = {
5883 (char *) "self",(char *) "rect", NULL
5884 };
5885
5886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5888 if (SWIG_arg_fail(1)) SWIG_fail;
5889 {
5890 arg2 = &temp2;
5891 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5892 }
5893 {
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = (arg1)->Union((wxRect const &)*arg2);
5896
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 {
5901 wxRect * resultptr;
5902 resultptr = new wxRect((wxRect &)(result));
5903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5904 }
5905 return resultobj;
5906 fail:
5907 return NULL;
5908 }
5909
5910
5911 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5912 PyObject *resultobj;
5913 wxRect *arg1 = (wxRect *) 0 ;
5914 wxRect *arg2 = 0 ;
5915 wxRect result;
5916 wxRect temp2 ;
5917 PyObject * obj0 = 0 ;
5918 PyObject * obj1 = 0 ;
5919 char *kwnames[] = {
5920 (char *) "self",(char *) "rect", NULL
5921 };
5922
5923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5925 if (SWIG_arg_fail(1)) SWIG_fail;
5926 {
5927 arg2 = &temp2;
5928 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5929 }
5930 {
5931 PyThreadState* __tstate = wxPyBeginAllowThreads();
5932 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5933
5934 wxPyEndAllowThreads(__tstate);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 {
5938 wxRect * resultptr;
5939 resultptr = new wxRect((wxRect &)(result));
5940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5941 }
5942 return resultobj;
5943 fail:
5944 return NULL;
5945 }
5946
5947
5948 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5949 PyObject *resultobj;
5950 wxRect *arg1 = (wxRect *) 0 ;
5951 wxRect *arg2 = 0 ;
5952 wxRect *result;
5953 wxRect temp2 ;
5954 PyObject * obj0 = 0 ;
5955 PyObject * obj1 = 0 ;
5956 char *kwnames[] = {
5957 (char *) "self",(char *) "rect", NULL
5958 };
5959
5960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5962 if (SWIG_arg_fail(1)) SWIG_fail;
5963 {
5964 arg2 = &temp2;
5965 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5966 }
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 {
5970 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5971 result = (wxRect *) &_result_ref;
5972 }
5973
5974 wxPyEndAllowThreads(__tstate);
5975 if (PyErr_Occurred()) SWIG_fail;
5976 }
5977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5978 return resultobj;
5979 fail:
5980 return NULL;
5981 }
5982
5983
5984 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5985 PyObject *resultobj;
5986 wxRect *arg1 = (wxRect *) 0 ;
5987 wxRect *arg2 = 0 ;
5988 bool result;
5989 wxRect temp2 ;
5990 PyObject * obj0 = 0 ;
5991 PyObject * obj1 = 0 ;
5992 char *kwnames[] = {
5993 (char *) "self",(char *) "rect", NULL
5994 };
5995
5996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5998 if (SWIG_arg_fail(1)) SWIG_fail;
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6006
6007 wxPyEndAllowThreads(__tstate);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 {
6011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6012 }
6013 return resultobj;
6014 fail:
6015 return NULL;
6016 }
6017
6018
6019 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6020 PyObject *resultobj;
6021 wxRect *arg1 = (wxRect *) 0 ;
6022 wxRect *arg2 = 0 ;
6023 bool result;
6024 wxRect temp2 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 char *kwnames[] = {
6028 (char *) "self",(char *) "rect", NULL
6029 };
6030
6031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6033 if (SWIG_arg_fail(1)) SWIG_fail;
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6041
6042 wxPyEndAllowThreads(__tstate);
6043 if (PyErr_Occurred()) SWIG_fail;
6044 }
6045 {
6046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6047 }
6048 return resultobj;
6049 fail:
6050 return NULL;
6051 }
6052
6053
6054 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6055 PyObject *resultobj;
6056 wxRect *arg1 = (wxRect *) 0 ;
6057 int arg2 ;
6058 int arg3 ;
6059 bool result;
6060 PyObject * obj0 = 0 ;
6061 PyObject * obj1 = 0 ;
6062 PyObject * obj2 = 0 ;
6063 char *kwnames[] = {
6064 (char *) "self",(char *) "x",(char *) "y", NULL
6065 };
6066
6067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6069 if (SWIG_arg_fail(1)) SWIG_fail;
6070 {
6071 arg2 = (int)(SWIG_As_int(obj1));
6072 if (SWIG_arg_fail(2)) SWIG_fail;
6073 }
6074 {
6075 arg3 = (int)(SWIG_As_int(obj2));
6076 if (SWIG_arg_fail(3)) SWIG_fail;
6077 }
6078 {
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6081
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 {
6086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6087 }
6088 return resultobj;
6089 fail:
6090 return NULL;
6091 }
6092
6093
6094 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj;
6096 wxRect *arg1 = (wxRect *) 0 ;
6097 wxPoint *arg2 = 0 ;
6098 bool result;
6099 wxPoint temp2 ;
6100 PyObject * obj0 = 0 ;
6101 PyObject * obj1 = 0 ;
6102 char *kwnames[] = {
6103 (char *) "self",(char *) "pt", NULL
6104 };
6105
6106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6108 if (SWIG_arg_fail(1)) SWIG_fail;
6109 {
6110 arg2 = &temp2;
6111 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6112 }
6113 {
6114 PyThreadState* __tstate = wxPyBeginAllowThreads();
6115 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6116
6117 wxPyEndAllowThreads(__tstate);
6118 if (PyErr_Occurred()) SWIG_fail;
6119 }
6120 {
6121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6122 }
6123 return resultobj;
6124 fail:
6125 return NULL;
6126 }
6127
6128
6129 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6130 PyObject *resultobj;
6131 wxRect *arg1 = (wxRect *) 0 ;
6132 wxRect *arg2 = 0 ;
6133 bool result;
6134 wxRect temp2 ;
6135 PyObject * obj0 = 0 ;
6136 PyObject * obj1 = 0 ;
6137 char *kwnames[] = {
6138 (char *) "self",(char *) "rect", NULL
6139 };
6140
6141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6143 if (SWIG_arg_fail(1)) SWIG_fail;
6144 {
6145 arg2 = &temp2;
6146 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6147 }
6148 {
6149 PyThreadState* __tstate = wxPyBeginAllowThreads();
6150 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6151
6152 wxPyEndAllowThreads(__tstate);
6153 if (PyErr_Occurred()) SWIG_fail;
6154 }
6155 {
6156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6157 }
6158 return resultobj;
6159 fail:
6160 return NULL;
6161 }
6162
6163
6164 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6165 PyObject *resultobj;
6166 wxRect *arg1 = (wxRect *) 0 ;
6167 int arg2 ;
6168 PyObject * obj0 = 0 ;
6169 PyObject * obj1 = 0 ;
6170 char *kwnames[] = {
6171 (char *) "self",(char *) "x", NULL
6172 };
6173
6174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6176 if (SWIG_arg_fail(1)) SWIG_fail;
6177 {
6178 arg2 = (int)(SWIG_As_int(obj1));
6179 if (SWIG_arg_fail(2)) SWIG_fail;
6180 }
6181 if (arg1) (arg1)->x = arg2;
6182
6183 Py_INCREF(Py_None); resultobj = Py_None;
6184 return resultobj;
6185 fail:
6186 return NULL;
6187 }
6188
6189
6190 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6191 PyObject *resultobj;
6192 wxRect *arg1 = (wxRect *) 0 ;
6193 int result;
6194 PyObject * obj0 = 0 ;
6195 char *kwnames[] = {
6196 (char *) "self", NULL
6197 };
6198
6199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6201 if (SWIG_arg_fail(1)) SWIG_fail;
6202 result = (int) ((arg1)->x);
6203
6204 {
6205 resultobj = SWIG_From_int((int)(result));
6206 }
6207 return resultobj;
6208 fail:
6209 return NULL;
6210 }
6211
6212
6213 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6214 PyObject *resultobj;
6215 wxRect *arg1 = (wxRect *) 0 ;
6216 int arg2 ;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 char *kwnames[] = {
6220 (char *) "self",(char *) "y", NULL
6221 };
6222
6223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6225 if (SWIG_arg_fail(1)) SWIG_fail;
6226 {
6227 arg2 = (int)(SWIG_As_int(obj1));
6228 if (SWIG_arg_fail(2)) SWIG_fail;
6229 }
6230 if (arg1) (arg1)->y = arg2;
6231
6232 Py_INCREF(Py_None); resultobj = Py_None;
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6240 PyObject *resultobj;
6241 wxRect *arg1 = (wxRect *) 0 ;
6242 int result;
6243 PyObject * obj0 = 0 ;
6244 char *kwnames[] = {
6245 (char *) "self", NULL
6246 };
6247
6248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6250 if (SWIG_arg_fail(1)) SWIG_fail;
6251 result = (int) ((arg1)->y);
6252
6253 {
6254 resultobj = SWIG_From_int((int)(result));
6255 }
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6263 PyObject *resultobj;
6264 wxRect *arg1 = (wxRect *) 0 ;
6265 int arg2 ;
6266 PyObject * obj0 = 0 ;
6267 PyObject * obj1 = 0 ;
6268 char *kwnames[] = {
6269 (char *) "self",(char *) "width", NULL
6270 };
6271
6272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6274 if (SWIG_arg_fail(1)) SWIG_fail;
6275 {
6276 arg2 = (int)(SWIG_As_int(obj1));
6277 if (SWIG_arg_fail(2)) SWIG_fail;
6278 }
6279 if (arg1) (arg1)->width = arg2;
6280
6281 Py_INCREF(Py_None); resultobj = Py_None;
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj;
6290 wxRect *arg1 = (wxRect *) 0 ;
6291 int result;
6292 PyObject * obj0 = 0 ;
6293 char *kwnames[] = {
6294 (char *) "self", NULL
6295 };
6296
6297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6299 if (SWIG_arg_fail(1)) SWIG_fail;
6300 result = (int) ((arg1)->width);
6301
6302 {
6303 resultobj = SWIG_From_int((int)(result));
6304 }
6305 return resultobj;
6306 fail:
6307 return NULL;
6308 }
6309
6310
6311 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6312 PyObject *resultobj;
6313 wxRect *arg1 = (wxRect *) 0 ;
6314 int arg2 ;
6315 PyObject * obj0 = 0 ;
6316 PyObject * obj1 = 0 ;
6317 char *kwnames[] = {
6318 (char *) "self",(char *) "height", NULL
6319 };
6320
6321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6323 if (SWIG_arg_fail(1)) SWIG_fail;
6324 {
6325 arg2 = (int)(SWIG_As_int(obj1));
6326 if (SWIG_arg_fail(2)) SWIG_fail;
6327 }
6328 if (arg1) (arg1)->height = arg2;
6329
6330 Py_INCREF(Py_None); resultobj = Py_None;
6331 return resultobj;
6332 fail:
6333 return NULL;
6334 }
6335
6336
6337 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6338 PyObject *resultobj;
6339 wxRect *arg1 = (wxRect *) 0 ;
6340 int result;
6341 PyObject * obj0 = 0 ;
6342 char *kwnames[] = {
6343 (char *) "self", NULL
6344 };
6345
6346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6348 if (SWIG_arg_fail(1)) SWIG_fail;
6349 result = (int) ((arg1)->height);
6350
6351 {
6352 resultobj = SWIG_From_int((int)(result));
6353 }
6354 return resultobj;
6355 fail:
6356 return NULL;
6357 }
6358
6359
6360 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6361 PyObject *resultobj;
6362 wxRect *arg1 = (wxRect *) 0 ;
6363 int arg2 = (int) 0 ;
6364 int arg3 = (int) 0 ;
6365 int arg4 = (int) 0 ;
6366 int arg5 = (int) 0 ;
6367 PyObject * obj0 = 0 ;
6368 PyObject * obj1 = 0 ;
6369 PyObject * obj2 = 0 ;
6370 PyObject * obj3 = 0 ;
6371 PyObject * obj4 = 0 ;
6372 char *kwnames[] = {
6373 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6374 };
6375
6376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6378 if (SWIG_arg_fail(1)) SWIG_fail;
6379 if (obj1) {
6380 {
6381 arg2 = (int)(SWIG_As_int(obj1));
6382 if (SWIG_arg_fail(2)) SWIG_fail;
6383 }
6384 }
6385 if (obj2) {
6386 {
6387 arg3 = (int)(SWIG_As_int(obj2));
6388 if (SWIG_arg_fail(3)) SWIG_fail;
6389 }
6390 }
6391 if (obj3) {
6392 {
6393 arg4 = (int)(SWIG_As_int(obj3));
6394 if (SWIG_arg_fail(4)) SWIG_fail;
6395 }
6396 }
6397 if (obj4) {
6398 {
6399 arg5 = (int)(SWIG_As_int(obj4));
6400 if (SWIG_arg_fail(5)) SWIG_fail;
6401 }
6402 }
6403 {
6404 PyThreadState* __tstate = wxPyBeginAllowThreads();
6405 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6406
6407 wxPyEndAllowThreads(__tstate);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 Py_INCREF(Py_None); resultobj = Py_None;
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj;
6419 wxRect *arg1 = (wxRect *) 0 ;
6420 PyObject *result;
6421 PyObject * obj0 = 0 ;
6422 char *kwnames[] = {
6423 (char *) "self", NULL
6424 };
6425
6426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6428 if (SWIG_arg_fail(1)) SWIG_fail;
6429 {
6430 PyThreadState* __tstate = wxPyBeginAllowThreads();
6431 result = (PyObject *)wxRect_Get(arg1);
6432
6433 wxPyEndAllowThreads(__tstate);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 resultobj = result;
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6444 PyObject *obj;
6445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6446 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6447 Py_INCREF(obj);
6448 return Py_BuildValue((char *)"");
6449 }
6450 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6451 PyObject *resultobj;
6452 wxRect *arg1 = (wxRect *) 0 ;
6453 wxRect *arg2 = (wxRect *) 0 ;
6454 PyObject *result;
6455 PyObject * obj0 = 0 ;
6456 PyObject * obj1 = 0 ;
6457 char *kwnames[] = {
6458 (char *) "r1",(char *) "r2", NULL
6459 };
6460
6461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6463 if (SWIG_arg_fail(1)) SWIG_fail;
6464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6465 if (SWIG_arg_fail(2)) SWIG_fail;
6466 {
6467 if (!wxPyCheckForApp()) SWIG_fail;
6468 PyThreadState* __tstate = wxPyBeginAllowThreads();
6469 result = (PyObject *)wxIntersectRect(arg1,arg2);
6470
6471 wxPyEndAllowThreads(__tstate);
6472 if (PyErr_Occurred()) SWIG_fail;
6473 }
6474 resultobj = result;
6475 return resultobj;
6476 fail:
6477 return NULL;
6478 }
6479
6480
6481 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6482 PyObject *resultobj;
6483 double arg1 = (double) 0.0 ;
6484 double arg2 = (double) 0.0 ;
6485 wxPoint2D *result;
6486 PyObject * obj0 = 0 ;
6487 PyObject * obj1 = 0 ;
6488 char *kwnames[] = {
6489 (char *) "x",(char *) "y", NULL
6490 };
6491
6492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6493 if (obj0) {
6494 {
6495 arg1 = (double)(SWIG_As_double(obj0));
6496 if (SWIG_arg_fail(1)) SWIG_fail;
6497 }
6498 }
6499 if (obj1) {
6500 {
6501 arg2 = (double)(SWIG_As_double(obj1));
6502 if (SWIG_arg_fail(2)) SWIG_fail;
6503 }
6504 }
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6520 PyObject *resultobj;
6521 wxPoint2D *arg1 = 0 ;
6522 wxPoint2D *result;
6523 wxPoint2D temp1 ;
6524 PyObject * obj0 = 0 ;
6525 char *kwnames[] = {
6526 (char *) "pt", NULL
6527 };
6528
6529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6530 {
6531 arg1 = &temp1;
6532 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6533 }
6534 {
6535 PyThreadState* __tstate = wxPyBeginAllowThreads();
6536 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6537
6538 wxPyEndAllowThreads(__tstate);
6539 if (PyErr_Occurred()) SWIG_fail;
6540 }
6541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6542 return resultobj;
6543 fail:
6544 return NULL;
6545 }
6546
6547
6548 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6549 PyObject *resultobj;
6550 wxPoint *arg1 = 0 ;
6551 wxPoint2D *result;
6552 wxPoint temp1 ;
6553 PyObject * obj0 = 0 ;
6554 char *kwnames[] = {
6555 (char *) "pt", NULL
6556 };
6557
6558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6559 {
6560 arg1 = &temp1;
6561 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6562 }
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6566
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6571 return resultobj;
6572 fail:
6573 return NULL;
6574 }
6575
6576
6577 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6578 PyObject *resultobj;
6579 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6580 int *arg2 = (int *) 0 ;
6581 int *arg3 = (int *) 0 ;
6582 int temp2 ;
6583 int res2 = 0 ;
6584 int temp3 ;
6585 int res3 = 0 ;
6586 PyObject * obj0 = 0 ;
6587 char *kwnames[] = {
6588 (char *) "self", NULL
6589 };
6590
6591 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6592 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6595 if (SWIG_arg_fail(1)) SWIG_fail;
6596 {
6597 PyThreadState* __tstate = wxPyBeginAllowThreads();
6598 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6599
6600 wxPyEndAllowThreads(__tstate);
6601 if (PyErr_Occurred()) SWIG_fail;
6602 }
6603 Py_INCREF(Py_None); resultobj = Py_None;
6604 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6605 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6606 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6607 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj;
6616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6617 int *arg2 = (int *) 0 ;
6618 int *arg3 = (int *) 0 ;
6619 int temp2 ;
6620 int res2 = 0 ;
6621 int temp3 ;
6622 int res3 = 0 ;
6623 PyObject * obj0 = 0 ;
6624 char *kwnames[] = {
6625 (char *) "self", NULL
6626 };
6627
6628 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6629 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6632 if (SWIG_arg_fail(1)) SWIG_fail;
6633 {
6634 PyThreadState* __tstate = wxPyBeginAllowThreads();
6635 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6636
6637 wxPyEndAllowThreads(__tstate);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 Py_INCREF(Py_None); resultobj = Py_None;
6641 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6642 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6643 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6644 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6652 PyObject *resultobj;
6653 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6654 double result;
6655 PyObject * obj0 = 0 ;
6656 char *kwnames[] = {
6657 (char *) "self", NULL
6658 };
6659
6660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6662 if (SWIG_arg_fail(1)) SWIG_fail;
6663 {
6664 PyThreadState* __tstate = wxPyBeginAllowThreads();
6665 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6666
6667 wxPyEndAllowThreads(__tstate);
6668 if (PyErr_Occurred()) SWIG_fail;
6669 }
6670 {
6671 resultobj = SWIG_From_double((double)(result));
6672 }
6673 return resultobj;
6674 fail:
6675 return NULL;
6676 }
6677
6678
6679 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6680 PyObject *resultobj;
6681 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6682 double result;
6683 PyObject * obj0 = 0 ;
6684 char *kwnames[] = {
6685 (char *) "self", NULL
6686 };
6687
6688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6690 if (SWIG_arg_fail(1)) SWIG_fail;
6691 {
6692 PyThreadState* __tstate = wxPyBeginAllowThreads();
6693 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6694
6695 wxPyEndAllowThreads(__tstate);
6696 if (PyErr_Occurred()) SWIG_fail;
6697 }
6698 {
6699 resultobj = SWIG_From_double((double)(result));
6700 }
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj;
6709 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6710 double arg2 ;
6711 PyObject * obj0 = 0 ;
6712 PyObject * obj1 = 0 ;
6713 char *kwnames[] = {
6714 (char *) "self",(char *) "length", NULL
6715 };
6716
6717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6719 if (SWIG_arg_fail(1)) SWIG_fail;
6720 {
6721 arg2 = (double)(SWIG_As_double(obj1));
6722 if (SWIG_arg_fail(2)) SWIG_fail;
6723 }
6724 {
6725 PyThreadState* __tstate = wxPyBeginAllowThreads();
6726 (arg1)->SetVectorLength(arg2);
6727
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 Py_INCREF(Py_None); resultobj = Py_None;
6732 return resultobj;
6733 fail:
6734 return NULL;
6735 }
6736
6737
6738 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6739 PyObject *resultobj;
6740 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6741 double arg2 ;
6742 PyObject * obj0 = 0 ;
6743 PyObject * obj1 = 0 ;
6744 char *kwnames[] = {
6745 (char *) "self",(char *) "degrees", NULL
6746 };
6747
6748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6750 if (SWIG_arg_fail(1)) SWIG_fail;
6751 {
6752 arg2 = (double)(SWIG_As_double(obj1));
6753 if (SWIG_arg_fail(2)) SWIG_fail;
6754 }
6755 {
6756 PyThreadState* __tstate = wxPyBeginAllowThreads();
6757 (arg1)->SetVectorAngle(arg2);
6758
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 Py_INCREF(Py_None); resultobj = Py_None;
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6770 PyObject *resultobj;
6771 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6772 wxPoint2D *arg2 = 0 ;
6773 double result;
6774 wxPoint2D temp2 ;
6775 PyObject * obj0 = 0 ;
6776 PyObject * obj1 = 0 ;
6777 char *kwnames[] = {
6778 (char *) "self",(char *) "pt", NULL
6779 };
6780
6781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6783 if (SWIG_arg_fail(1)) SWIG_fail;
6784 {
6785 arg2 = &temp2;
6786 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6787 }
6788 {
6789 PyThreadState* __tstate = wxPyBeginAllowThreads();
6790 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6791
6792 wxPyEndAllowThreads(__tstate);
6793 if (PyErr_Occurred()) SWIG_fail;
6794 }
6795 {
6796 resultobj = SWIG_From_double((double)(result));
6797 }
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6805 PyObject *resultobj;
6806 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6807 wxPoint2D *arg2 = 0 ;
6808 double result;
6809 wxPoint2D temp2 ;
6810 PyObject * obj0 = 0 ;
6811 PyObject * obj1 = 0 ;
6812 char *kwnames[] = {
6813 (char *) "self",(char *) "pt", NULL
6814 };
6815
6816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6818 if (SWIG_arg_fail(1)) SWIG_fail;
6819 {
6820 arg2 = &temp2;
6821 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6822 }
6823 {
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6826
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 {
6831 resultobj = SWIG_From_double((double)(result));
6832 }
6833 return resultobj;
6834 fail:
6835 return NULL;
6836 }
6837
6838
6839 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6840 PyObject *resultobj;
6841 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6842 wxPoint2D *arg2 = 0 ;
6843 double result;
6844 wxPoint2D temp2 ;
6845 PyObject * obj0 = 0 ;
6846 PyObject * obj1 = 0 ;
6847 char *kwnames[] = {
6848 (char *) "self",(char *) "vec", NULL
6849 };
6850
6851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6853 if (SWIG_arg_fail(1)) SWIG_fail;
6854 {
6855 arg2 = &temp2;
6856 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6857 }
6858 {
6859 PyThreadState* __tstate = wxPyBeginAllowThreads();
6860 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6861
6862 wxPyEndAllowThreads(__tstate);
6863 if (PyErr_Occurred()) SWIG_fail;
6864 }
6865 {
6866 resultobj = SWIG_From_double((double)(result));
6867 }
6868 return resultobj;
6869 fail:
6870 return NULL;
6871 }
6872
6873
6874 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6875 PyObject *resultobj;
6876 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6877 wxPoint2D *arg2 = 0 ;
6878 double result;
6879 wxPoint2D temp2 ;
6880 PyObject * obj0 = 0 ;
6881 PyObject * obj1 = 0 ;
6882 char *kwnames[] = {
6883 (char *) "self",(char *) "vec", NULL
6884 };
6885
6886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6888 if (SWIG_arg_fail(1)) SWIG_fail;
6889 {
6890 arg2 = &temp2;
6891 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6892 }
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6896
6897 wxPyEndAllowThreads(__tstate);
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 {
6901 resultobj = SWIG_From_double((double)(result));
6902 }
6903 return resultobj;
6904 fail:
6905 return NULL;
6906 }
6907
6908
6909 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6910 PyObject *resultobj;
6911 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6912 wxPoint2D result;
6913 PyObject * obj0 = 0 ;
6914 char *kwnames[] = {
6915 (char *) "self", NULL
6916 };
6917
6918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6920 if (SWIG_arg_fail(1)) SWIG_fail;
6921 {
6922 PyThreadState* __tstate = wxPyBeginAllowThreads();
6923 result = (arg1)->operator -();
6924
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 {
6929 wxPoint2D * resultptr;
6930 resultptr = new wxPoint2D((wxPoint2D &)(result));
6931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6932 }
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj;
6941 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6942 wxPoint2D *arg2 = 0 ;
6943 wxPoint2D *result;
6944 wxPoint2D temp2 ;
6945 PyObject * obj0 = 0 ;
6946 PyObject * obj1 = 0 ;
6947 char *kwnames[] = {
6948 (char *) "self",(char *) "pt", NULL
6949 };
6950
6951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6953 if (SWIG_arg_fail(1)) SWIG_fail;
6954 {
6955 arg2 = &temp2;
6956 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6957 }
6958 {
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 {
6961 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6962 result = (wxPoint2D *) &_result_ref;
6963 }
6964
6965 wxPyEndAllowThreads(__tstate);
6966 if (PyErr_Occurred()) SWIG_fail;
6967 }
6968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6969 return resultobj;
6970 fail:
6971 return NULL;
6972 }
6973
6974
6975 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6976 PyObject *resultobj;
6977 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6978 wxPoint2D *arg2 = 0 ;
6979 wxPoint2D *result;
6980 wxPoint2D temp2 ;
6981 PyObject * obj0 = 0 ;
6982 PyObject * obj1 = 0 ;
6983 char *kwnames[] = {
6984 (char *) "self",(char *) "pt", NULL
6985 };
6986
6987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6989 if (SWIG_arg_fail(1)) SWIG_fail;
6990 {
6991 arg2 = &temp2;
6992 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6993 }
6994 {
6995 PyThreadState* __tstate = wxPyBeginAllowThreads();
6996 {
6997 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6998 result = (wxPoint2D *) &_result_ref;
6999 }
7000
7001 wxPyEndAllowThreads(__tstate);
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7005 return resultobj;
7006 fail:
7007 return NULL;
7008 }
7009
7010
7011 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7012 PyObject *resultobj;
7013 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7014 wxPoint2D *arg2 = 0 ;
7015 wxPoint2D *result;
7016 wxPoint2D temp2 ;
7017 PyObject * obj0 = 0 ;
7018 PyObject * obj1 = 0 ;
7019 char *kwnames[] = {
7020 (char *) "self",(char *) "pt", NULL
7021 };
7022
7023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7025 if (SWIG_arg_fail(1)) SWIG_fail;
7026 {
7027 arg2 = &temp2;
7028 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7029 }
7030 {
7031 PyThreadState* __tstate = wxPyBeginAllowThreads();
7032 {
7033 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7034 result = (wxPoint2D *) &_result_ref;
7035 }
7036
7037 wxPyEndAllowThreads(__tstate);
7038 if (PyErr_Occurred()) SWIG_fail;
7039 }
7040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7041 return resultobj;
7042 fail:
7043 return NULL;
7044 }
7045
7046
7047 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7048 PyObject *resultobj;
7049 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7050 wxPoint2D *arg2 = 0 ;
7051 wxPoint2D *result;
7052 wxPoint2D temp2 ;
7053 PyObject * obj0 = 0 ;
7054 PyObject * obj1 = 0 ;
7055 char *kwnames[] = {
7056 (char *) "self",(char *) "pt", NULL
7057 };
7058
7059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7061 if (SWIG_arg_fail(1)) SWIG_fail;
7062 {
7063 arg2 = &temp2;
7064 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7065 }
7066 {
7067 PyThreadState* __tstate = wxPyBeginAllowThreads();
7068 {
7069 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7070 result = (wxPoint2D *) &_result_ref;
7071 }
7072
7073 wxPyEndAllowThreads(__tstate);
7074 if (PyErr_Occurred()) SWIG_fail;
7075 }
7076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7077 return resultobj;
7078 fail:
7079 return NULL;
7080 }
7081
7082
7083 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7084 PyObject *resultobj;
7085 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7086 wxPoint2D *arg2 = 0 ;
7087 bool result;
7088 wxPoint2D temp2 ;
7089 PyObject * obj0 = 0 ;
7090 PyObject * obj1 = 0 ;
7091 char *kwnames[] = {
7092 (char *) "self",(char *) "pt", NULL
7093 };
7094
7095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7097 if (SWIG_arg_fail(1)) SWIG_fail;
7098 {
7099 arg2 = &temp2;
7100 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7101 }
7102 {
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7105
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 {
7110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7111 }
7112 return resultobj;
7113 fail:
7114 return NULL;
7115 }
7116
7117
7118 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7119 PyObject *resultobj;
7120 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7121 wxPoint2D *arg2 = 0 ;
7122 bool result;
7123 wxPoint2D temp2 ;
7124 PyObject * obj0 = 0 ;
7125 PyObject * obj1 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self",(char *) "pt", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 {
7134 arg2 = &temp2;
7135 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7136 }
7137 {
7138 PyThreadState* __tstate = wxPyBeginAllowThreads();
7139 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7140
7141 wxPyEndAllowThreads(__tstate);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 {
7145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7146 }
7147 return resultobj;
7148 fail:
7149 return NULL;
7150 }
7151
7152
7153 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7154 PyObject *resultobj;
7155 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7156 double arg2 ;
7157 PyObject * obj0 = 0 ;
7158 PyObject * obj1 = 0 ;
7159 char *kwnames[] = {
7160 (char *) "self",(char *) "m_x", NULL
7161 };
7162
7163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7165 if (SWIG_arg_fail(1)) SWIG_fail;
7166 {
7167 arg2 = (double)(SWIG_As_double(obj1));
7168 if (SWIG_arg_fail(2)) SWIG_fail;
7169 }
7170 if (arg1) (arg1)->m_x = arg2;
7171
7172 Py_INCREF(Py_None); resultobj = Py_None;
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7180 PyObject *resultobj;
7181 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7182 double result;
7183 PyObject * obj0 = 0 ;
7184 char *kwnames[] = {
7185 (char *) "self", NULL
7186 };
7187
7188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7190 if (SWIG_arg_fail(1)) SWIG_fail;
7191 result = (double) ((arg1)->m_x);
7192
7193 {
7194 resultobj = SWIG_From_double((double)(result));
7195 }
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj;
7204 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7205 double arg2 ;
7206 PyObject * obj0 = 0 ;
7207 PyObject * obj1 = 0 ;
7208 char *kwnames[] = {
7209 (char *) "self",(char *) "m_y", NULL
7210 };
7211
7212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7214 if (SWIG_arg_fail(1)) SWIG_fail;
7215 {
7216 arg2 = (double)(SWIG_As_double(obj1));
7217 if (SWIG_arg_fail(2)) SWIG_fail;
7218 }
7219 if (arg1) (arg1)->m_y = arg2;
7220
7221 Py_INCREF(Py_None); resultobj = Py_None;
7222 return resultobj;
7223 fail:
7224 return NULL;
7225 }
7226
7227
7228 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7229 PyObject *resultobj;
7230 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7231 double result;
7232 PyObject * obj0 = 0 ;
7233 char *kwnames[] = {
7234 (char *) "self", NULL
7235 };
7236
7237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7239 if (SWIG_arg_fail(1)) SWIG_fail;
7240 result = (double) ((arg1)->m_y);
7241
7242 {
7243 resultobj = SWIG_From_double((double)(result));
7244 }
7245 return resultobj;
7246 fail:
7247 return NULL;
7248 }
7249
7250
7251 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7252 PyObject *resultobj;
7253 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7254 double arg2 = (double) 0 ;
7255 double arg3 = (double) 0 ;
7256 PyObject * obj0 = 0 ;
7257 PyObject * obj1 = 0 ;
7258 PyObject * obj2 = 0 ;
7259 char *kwnames[] = {
7260 (char *) "self",(char *) "x",(char *) "y", NULL
7261 };
7262
7263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7265 if (SWIG_arg_fail(1)) SWIG_fail;
7266 if (obj1) {
7267 {
7268 arg2 = (double)(SWIG_As_double(obj1));
7269 if (SWIG_arg_fail(2)) SWIG_fail;
7270 }
7271 }
7272 if (obj2) {
7273 {
7274 arg3 = (double)(SWIG_As_double(obj2));
7275 if (SWIG_arg_fail(3)) SWIG_fail;
7276 }
7277 }
7278 {
7279 PyThreadState* __tstate = wxPyBeginAllowThreads();
7280 wxPoint2D_Set(arg1,arg2,arg3);
7281
7282 wxPyEndAllowThreads(__tstate);
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 Py_INCREF(Py_None); resultobj = Py_None;
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj;
7294 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7295 PyObject *result;
7296 PyObject * obj0 = 0 ;
7297 char *kwnames[] = {
7298 (char *) "self", NULL
7299 };
7300
7301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7303 if (SWIG_arg_fail(1)) SWIG_fail;
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = (PyObject *)wxPoint2D_Get(arg1);
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 resultobj = result;
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7319 PyObject *obj;
7320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7321 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7322 Py_INCREF(obj);
7323 return Py_BuildValue((char *)"");
7324 }
7325 static int _wrap_DefaultPosition_set(PyObject *) {
7326 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7327 return 1;
7328 }
7329
7330
7331 static PyObject *_wrap_DefaultPosition_get(void) {
7332 PyObject *pyobj;
7333
7334 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7335 return pyobj;
7336 }
7337
7338
7339 static int _wrap_DefaultSize_set(PyObject *) {
7340 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7341 return 1;
7342 }
7343
7344
7345 static PyObject *_wrap_DefaultSize_get(void) {
7346 PyObject *pyobj;
7347
7348 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7349 return pyobj;
7350 }
7351
7352
7353 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7354 PyObject *resultobj;
7355 PyObject *arg1 = (PyObject *) 0 ;
7356 wxPyInputStream *result;
7357 PyObject * obj0 = 0 ;
7358 char *kwnames[] = {
7359 (char *) "p", NULL
7360 };
7361
7362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7363 arg1 = obj0;
7364 {
7365 PyThreadState* __tstate = wxPyBeginAllowThreads();
7366 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7367
7368 wxPyEndAllowThreads(__tstate);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7379 PyObject *resultobj;
7380 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7381 PyObject * obj0 = 0 ;
7382 char *kwnames[] = {
7383 (char *) "self", NULL
7384 };
7385
7386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7388 if (SWIG_arg_fail(1)) SWIG_fail;
7389 {
7390 PyThreadState* __tstate = wxPyBeginAllowThreads();
7391 delete arg1;
7392
7393 wxPyEndAllowThreads(__tstate);
7394 if (PyErr_Occurred()) SWIG_fail;
7395 }
7396 Py_INCREF(Py_None); resultobj = Py_None;
7397 return resultobj;
7398 fail:
7399 return NULL;
7400 }
7401
7402
7403 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7404 PyObject *resultobj;
7405 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7406 PyObject * obj0 = 0 ;
7407 char *kwnames[] = {
7408 (char *) "self", NULL
7409 };
7410
7411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7413 if (SWIG_arg_fail(1)) SWIG_fail;
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 (arg1)->close();
7417
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 Py_INCREF(Py_None); resultobj = Py_None;
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj;
7430 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7431 PyObject * obj0 = 0 ;
7432 char *kwnames[] = {
7433 (char *) "self", NULL
7434 };
7435
7436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7438 if (SWIG_arg_fail(1)) SWIG_fail;
7439 {
7440 PyThreadState* __tstate = wxPyBeginAllowThreads();
7441 (arg1)->flush();
7442
7443 wxPyEndAllowThreads(__tstate);
7444 if (PyErr_Occurred()) SWIG_fail;
7445 }
7446 Py_INCREF(Py_None); resultobj = Py_None;
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj;
7455 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7456 bool result;
7457 PyObject * obj0 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 result = (bool)(arg1)->eof();
7468
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 {
7473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7474 }
7475 return resultobj;
7476 fail:
7477 return NULL;
7478 }
7479
7480
7481 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7482 PyObject *resultobj;
7483 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7484 int arg2 = (int) -1 ;
7485 PyObject *result;
7486 PyObject * obj0 = 0 ;
7487 PyObject * obj1 = 0 ;
7488 char *kwnames[] = {
7489 (char *) "self",(char *) "size", NULL
7490 };
7491
7492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7494 if (SWIG_arg_fail(1)) SWIG_fail;
7495 if (obj1) {
7496 {
7497 arg2 = (int)(SWIG_As_int(obj1));
7498 if (SWIG_arg_fail(2)) SWIG_fail;
7499 }
7500 }
7501 {
7502 PyThreadState* __tstate = wxPyBeginAllowThreads();
7503 result = (PyObject *)(arg1)->read(arg2);
7504
7505 wxPyEndAllowThreads(__tstate);
7506 if (PyErr_Occurred()) SWIG_fail;
7507 }
7508 resultobj = result;
7509 return resultobj;
7510 fail:
7511 return NULL;
7512 }
7513
7514
7515 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj;
7517 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7518 int arg2 = (int) -1 ;
7519 PyObject *result;
7520 PyObject * obj0 = 0 ;
7521 PyObject * obj1 = 0 ;
7522 char *kwnames[] = {
7523 (char *) "self",(char *) "size", NULL
7524 };
7525
7526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7528 if (SWIG_arg_fail(1)) SWIG_fail;
7529 if (obj1) {
7530 {
7531 arg2 = (int)(SWIG_As_int(obj1));
7532 if (SWIG_arg_fail(2)) SWIG_fail;
7533 }
7534 }
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 result = (PyObject *)(arg1)->readline(arg2);
7538
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 resultobj = result;
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj;
7551 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7552 int arg2 = (int) -1 ;
7553 PyObject *result;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 char *kwnames[] = {
7557 (char *) "self",(char *) "sizehint", NULL
7558 };
7559
7560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7562 if (SWIG_arg_fail(1)) SWIG_fail;
7563 if (obj1) {
7564 {
7565 arg2 = (int)(SWIG_As_int(obj1));
7566 if (SWIG_arg_fail(2)) SWIG_fail;
7567 }
7568 }
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (PyObject *)(arg1)->readlines(arg2);
7572
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 resultobj = result;
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj;
7585 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7586 int arg2 ;
7587 int arg3 = (int) 0 ;
7588 PyObject * obj0 = 0 ;
7589 PyObject * obj1 = 0 ;
7590 PyObject * obj2 = 0 ;
7591 char *kwnames[] = {
7592 (char *) "self",(char *) "offset",(char *) "whence", NULL
7593 };
7594
7595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7597 if (SWIG_arg_fail(1)) SWIG_fail;
7598 {
7599 arg2 = (int)(SWIG_As_int(obj1));
7600 if (SWIG_arg_fail(2)) SWIG_fail;
7601 }
7602 if (obj2) {
7603 {
7604 arg3 = (int)(SWIG_As_int(obj2));
7605 if (SWIG_arg_fail(3)) SWIG_fail;
7606 }
7607 }
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 (arg1)->seek(arg2,arg3);
7611
7612 wxPyEndAllowThreads(__tstate);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 Py_INCREF(Py_None); resultobj = Py_None;
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj;
7624 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7625 int result;
7626 PyObject * obj0 = 0 ;
7627 char *kwnames[] = {
7628 (char *) "self", NULL
7629 };
7630
7631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7633 if (SWIG_arg_fail(1)) SWIG_fail;
7634 {
7635 PyThreadState* __tstate = wxPyBeginAllowThreads();
7636 result = (int)(arg1)->tell();
7637
7638 wxPyEndAllowThreads(__tstate);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 {
7642 resultobj = SWIG_From_int((int)(result));
7643 }
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7651 PyObject *resultobj;
7652 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7653 char result;
7654 PyObject * obj0 = 0 ;
7655 char *kwnames[] = {
7656 (char *) "self", NULL
7657 };
7658
7659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7661 if (SWIG_arg_fail(1)) SWIG_fail;
7662 {
7663 PyThreadState* __tstate = wxPyBeginAllowThreads();
7664 result = (char)(arg1)->Peek();
7665
7666 wxPyEndAllowThreads(__tstate);
7667 if (PyErr_Occurred()) SWIG_fail;
7668 }
7669 {
7670 resultobj = SWIG_From_char((char)(result));
7671 }
7672 return resultobj;
7673 fail:
7674 return NULL;
7675 }
7676
7677
7678 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7679 PyObject *resultobj;
7680 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7681 char result;
7682 PyObject * obj0 = 0 ;
7683 char *kwnames[] = {
7684 (char *) "self", NULL
7685 };
7686
7687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7689 if (SWIG_arg_fail(1)) SWIG_fail;
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 result = (char)(arg1)->GetC();
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = SWIG_From_char((char)(result));
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj;
7708 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7709 size_t result;
7710 PyObject * obj0 = 0 ;
7711 char *kwnames[] = {
7712 (char *) "self", NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7717 if (SWIG_arg_fail(1)) SWIG_fail;
7718 {
7719 PyThreadState* __tstate = wxPyBeginAllowThreads();
7720 result = (size_t)(arg1)->LastRead();
7721
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 {
7726 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7727 }
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj;
7736 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7737 bool result;
7738 PyObject * obj0 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 result = (bool)(arg1)->CanRead();
7749
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 {
7754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7755 }
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7763 PyObject *resultobj;
7764 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7765 bool result;
7766 PyObject * obj0 = 0 ;
7767 char *kwnames[] = {
7768 (char *) "self", NULL
7769 };
7770
7771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7773 if (SWIG_arg_fail(1)) SWIG_fail;
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (bool)(arg1)->Eof();
7777
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 {
7782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7783 }
7784 return resultobj;
7785 fail:
7786 return NULL;
7787 }
7788
7789
7790 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7791 PyObject *resultobj;
7792 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7793 char arg2 ;
7794 bool result;
7795 PyObject * obj0 = 0 ;
7796 PyObject * obj1 = 0 ;
7797 char *kwnames[] = {
7798 (char *) "self",(char *) "c", NULL
7799 };
7800
7801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7803 if (SWIG_arg_fail(1)) SWIG_fail;
7804 {
7805 arg2 = (char)(SWIG_As_char(obj1));
7806 if (SWIG_arg_fail(2)) SWIG_fail;
7807 }
7808 {
7809 PyThreadState* __tstate = wxPyBeginAllowThreads();
7810 result = (bool)(arg1)->Ungetch(arg2);
7811
7812 wxPyEndAllowThreads(__tstate);
7813 if (PyErr_Occurred()) SWIG_fail;
7814 }
7815 {
7816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7817 }
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7825 PyObject *resultobj;
7826 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7827 long arg2 ;
7828 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7829 long result;
7830 PyObject * obj0 = 0 ;
7831 PyObject * obj1 = 0 ;
7832 PyObject * obj2 = 0 ;
7833 char *kwnames[] = {
7834 (char *) "self",(char *) "pos",(char *) "mode", NULL
7835 };
7836
7837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7839 if (SWIG_arg_fail(1)) SWIG_fail;
7840 {
7841 arg2 = (long)(SWIG_As_long(obj1));
7842 if (SWIG_arg_fail(2)) SWIG_fail;
7843 }
7844 if (obj2) {
7845 {
7846 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7847 if (SWIG_arg_fail(3)) SWIG_fail;
7848 }
7849 }
7850 {
7851 PyThreadState* __tstate = wxPyBeginAllowThreads();
7852 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7853
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 {
7858 resultobj = SWIG_From_long((long)(result));
7859 }
7860 return resultobj;
7861 fail:
7862 return NULL;
7863 }
7864
7865
7866 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7867 PyObject *resultobj;
7868 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7869 long result;
7870 PyObject * obj0 = 0 ;
7871 char *kwnames[] = {
7872 (char *) "self", NULL
7873 };
7874
7875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7877 if (SWIG_arg_fail(1)) SWIG_fail;
7878 {
7879 PyThreadState* __tstate = wxPyBeginAllowThreads();
7880 result = (long)(arg1)->TellI();
7881
7882 wxPyEndAllowThreads(__tstate);
7883 if (PyErr_Occurred()) SWIG_fail;
7884 }
7885 {
7886 resultobj = SWIG_From_long((long)(result));
7887 }
7888 return resultobj;
7889 fail:
7890 return NULL;
7891 }
7892
7893
7894 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7895 PyObject *obj;
7896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7897 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7898 Py_INCREF(obj);
7899 return Py_BuildValue((char *)"");
7900 }
7901 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7902 PyObject *resultobj;
7903 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7904 PyObject *arg2 = (PyObject *) 0 ;
7905 PyObject * obj0 = 0 ;
7906 PyObject * obj1 = 0 ;
7907 char *kwnames[] = {
7908 (char *) "self",(char *) "obj", NULL
7909 };
7910
7911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7913 if (SWIG_arg_fail(1)) SWIG_fail;
7914 arg2 = obj1;
7915 {
7916 PyThreadState* __tstate = wxPyBeginAllowThreads();
7917 wxOutputStream_write(arg1,arg2);
7918
7919 wxPyEndAllowThreads(__tstate);
7920 if (PyErr_Occurred()) SWIG_fail;
7921 }
7922 Py_INCREF(Py_None); resultobj = Py_None;
7923 return resultobj;
7924 fail:
7925 return NULL;
7926 }
7927
7928
7929 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7930 PyObject *obj;
7931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7932 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7933 Py_INCREF(obj);
7934 return Py_BuildValue((char *)"");
7935 }
7936 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj;
7938 wxInputStream *arg1 = (wxInputStream *) 0 ;
7939 wxString *arg2 = 0 ;
7940 wxString *arg3 = 0 ;
7941 wxString *arg4 = 0 ;
7942 wxDateTime arg5 ;
7943 wxFSFile *result;
7944 wxPyInputStream *temp1 ;
7945 bool temp2 = false ;
7946 bool temp3 = false ;
7947 bool temp4 = false ;
7948 PyObject * obj0 = 0 ;
7949 PyObject * obj1 = 0 ;
7950 PyObject * obj2 = 0 ;
7951 PyObject * obj3 = 0 ;
7952 PyObject * obj4 = 0 ;
7953 char *kwnames[] = {
7954 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7955 };
7956
7957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7958 {
7959 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7960 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7961 } else {
7962 PyErr_Clear(); // clear the failure of the wxPyConvert above
7963 arg1 = wxPyCBInputStream_create(obj0, true);
7964 if (arg1 == NULL) {
7965 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7966 SWIG_fail;
7967 }
7968 }
7969 }
7970 {
7971 arg2 = wxString_in_helper(obj1);
7972 if (arg2 == NULL) SWIG_fail;
7973 temp2 = true;
7974 }
7975 {
7976 arg3 = wxString_in_helper(obj2);
7977 if (arg3 == NULL) SWIG_fail;
7978 temp3 = true;
7979 }
7980 {
7981 arg4 = wxString_in_helper(obj3);
7982 if (arg4 == NULL) SWIG_fail;
7983 temp4 = true;
7984 }
7985 {
7986 wxDateTime * argp;
7987 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7988 if (SWIG_arg_fail(5)) SWIG_fail;
7989 if (argp == NULL) {
7990 SWIG_null_ref("wxDateTime");
7991 }
7992 if (SWIG_arg_fail(5)) SWIG_fail;
7993 arg5 = *argp;
7994 }
7995 {
7996 PyThreadState* __tstate = wxPyBeginAllowThreads();
7997 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7998
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 {
8003 resultobj = wxPyMake_wxObject(result, 1);
8004 }
8005 {
8006 if (temp2)
8007 delete arg2;
8008 }
8009 {
8010 if (temp3)
8011 delete arg3;
8012 }
8013 {
8014 if (temp4)
8015 delete arg4;
8016 }
8017 return resultobj;
8018 fail:
8019 {
8020 if (temp2)
8021 delete arg2;
8022 }
8023 {
8024 if (temp3)
8025 delete arg3;
8026 }
8027 {
8028 if (temp4)
8029 delete arg4;
8030 }
8031 return NULL;
8032 }
8033
8034
8035 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8036 PyObject *resultobj;
8037 wxFSFile *arg1 = (wxFSFile *) 0 ;
8038 PyObject * obj0 = 0 ;
8039 char *kwnames[] = {
8040 (char *) "self", NULL
8041 };
8042
8043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8045 if (SWIG_arg_fail(1)) SWIG_fail;
8046 {
8047 PyThreadState* __tstate = wxPyBeginAllowThreads();
8048 delete arg1;
8049
8050 wxPyEndAllowThreads(__tstate);
8051 if (PyErr_Occurred()) SWIG_fail;
8052 }
8053 Py_INCREF(Py_None); resultobj = Py_None;
8054 return resultobj;
8055 fail:
8056 return NULL;
8057 }
8058
8059
8060 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8061 PyObject *resultobj;
8062 wxFSFile *arg1 = (wxFSFile *) 0 ;
8063 wxInputStream *result;
8064 PyObject * obj0 = 0 ;
8065 char *kwnames[] = {
8066 (char *) "self", NULL
8067 };
8068
8069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8071 if (SWIG_arg_fail(1)) SWIG_fail;
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 result = (wxInputStream *)(arg1)->GetStream();
8075
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 {
8080 wxPyInputStream * _ptr = NULL;
8081
8082 if (result) {
8083 _ptr = new wxPyInputStream(result);
8084 }
8085 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8086 }
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8094 PyObject *resultobj;
8095 wxFSFile *arg1 = (wxFSFile *) 0 ;
8096 wxString *result;
8097 PyObject * obj0 = 0 ;
8098 char *kwnames[] = {
8099 (char *) "self", NULL
8100 };
8101
8102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8104 if (SWIG_arg_fail(1)) SWIG_fail;
8105 {
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 {
8108 wxString const &_result_ref = (arg1)->GetMimeType();
8109 result = (wxString *) &_result_ref;
8110 }
8111
8112 wxPyEndAllowThreads(__tstate);
8113 if (PyErr_Occurred()) SWIG_fail;
8114 }
8115 {
8116 #if wxUSE_UNICODE
8117 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8118 #else
8119 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8120 #endif
8121 }
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj;
8130 wxFSFile *arg1 = (wxFSFile *) 0 ;
8131 wxString *result;
8132 PyObject * obj0 = 0 ;
8133 char *kwnames[] = {
8134 (char *) "self", NULL
8135 };
8136
8137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8139 if (SWIG_arg_fail(1)) SWIG_fail;
8140 {
8141 PyThreadState* __tstate = wxPyBeginAllowThreads();
8142 {
8143 wxString const &_result_ref = (arg1)->GetLocation();
8144 result = (wxString *) &_result_ref;
8145 }
8146
8147 wxPyEndAllowThreads(__tstate);
8148 if (PyErr_Occurred()) SWIG_fail;
8149 }
8150 {
8151 #if wxUSE_UNICODE
8152 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8153 #else
8154 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8155 #endif
8156 }
8157 return resultobj;
8158 fail:
8159 return NULL;
8160 }
8161
8162
8163 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj;
8165 wxFSFile *arg1 = (wxFSFile *) 0 ;
8166 wxString *result;
8167 PyObject * obj0 = 0 ;
8168 char *kwnames[] = {
8169 (char *) "self", NULL
8170 };
8171
8172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8174 if (SWIG_arg_fail(1)) SWIG_fail;
8175 {
8176 PyThreadState* __tstate = wxPyBeginAllowThreads();
8177 {
8178 wxString const &_result_ref = (arg1)->GetAnchor();
8179 result = (wxString *) &_result_ref;
8180 }
8181
8182 wxPyEndAllowThreads(__tstate);
8183 if (PyErr_Occurred()) SWIG_fail;
8184 }
8185 {
8186 #if wxUSE_UNICODE
8187 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8188 #else
8189 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8190 #endif
8191 }
8192 return resultobj;
8193 fail:
8194 return NULL;
8195 }
8196
8197
8198 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8199 PyObject *resultobj;
8200 wxFSFile *arg1 = (wxFSFile *) 0 ;
8201 wxDateTime result;
8202 PyObject * obj0 = 0 ;
8203 char *kwnames[] = {
8204 (char *) "self", NULL
8205 };
8206
8207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8209 if (SWIG_arg_fail(1)) SWIG_fail;
8210 {
8211 PyThreadState* __tstate = wxPyBeginAllowThreads();
8212 result = (arg1)->GetModificationTime();
8213
8214 wxPyEndAllowThreads(__tstate);
8215 if (PyErr_Occurred()) SWIG_fail;
8216 }
8217 {
8218 wxDateTime * resultptr;
8219 resultptr = new wxDateTime((wxDateTime &)(result));
8220 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8221 }
8222 return resultobj;
8223 fail:
8224 return NULL;
8225 }
8226
8227
8228 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8229 PyObject *obj;
8230 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8231 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8232 Py_INCREF(obj);
8233 return Py_BuildValue((char *)"");
8234 }
8235 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8236 PyObject *obj;
8237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8238 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8239 Py_INCREF(obj);
8240 return Py_BuildValue((char *)"");
8241 }
8242 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8243 PyObject *resultobj;
8244 wxPyFileSystemHandler *result;
8245 char *kwnames[] = {
8246 NULL
8247 };
8248
8249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8253
8254 wxPyEndAllowThreads(__tstate);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj;
8266 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8267 PyObject *arg2 = (PyObject *) 0 ;
8268 PyObject *arg3 = (PyObject *) 0 ;
8269 PyObject * obj0 = 0 ;
8270 PyObject * obj1 = 0 ;
8271 PyObject * obj2 = 0 ;
8272 char *kwnames[] = {
8273 (char *) "self",(char *) "self",(char *) "_class", NULL
8274 };
8275
8276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8278 if (SWIG_arg_fail(1)) SWIG_fail;
8279 arg2 = obj1;
8280 arg3 = obj2;
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 (arg1)->_setCallbackInfo(arg2,arg3);
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 Py_INCREF(Py_None); resultobj = Py_None;
8289 return resultobj;
8290 fail:
8291 return NULL;
8292 }
8293
8294
8295 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8296 PyObject *resultobj;
8297 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8298 wxString *arg2 = 0 ;
8299 bool result;
8300 bool temp2 = false ;
8301 PyObject * obj0 = 0 ;
8302 PyObject * obj1 = 0 ;
8303 char *kwnames[] = {
8304 (char *) "self",(char *) "location", NULL
8305 };
8306
8307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8309 if (SWIG_arg_fail(1)) SWIG_fail;
8310 {
8311 arg2 = wxString_in_helper(obj1);
8312 if (arg2 == NULL) SWIG_fail;
8313 temp2 = true;
8314 }
8315 {
8316 PyThreadState* __tstate = wxPyBeginAllowThreads();
8317 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8318
8319 wxPyEndAllowThreads(__tstate);
8320 if (PyErr_Occurred()) SWIG_fail;
8321 }
8322 {
8323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8324 }
8325 {
8326 if (temp2)
8327 delete arg2;
8328 }
8329 return resultobj;
8330 fail:
8331 {
8332 if (temp2)
8333 delete arg2;
8334 }
8335 return NULL;
8336 }
8337
8338
8339 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj;
8341 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8342 wxFileSystem *arg2 = 0 ;
8343 wxString *arg3 = 0 ;
8344 wxFSFile *result;
8345 bool temp3 = false ;
8346 PyObject * obj0 = 0 ;
8347 PyObject * obj1 = 0 ;
8348 PyObject * obj2 = 0 ;
8349 char *kwnames[] = {
8350 (char *) "self",(char *) "fs",(char *) "location", NULL
8351 };
8352
8353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8355 if (SWIG_arg_fail(1)) SWIG_fail;
8356 {
8357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8358 if (SWIG_arg_fail(2)) SWIG_fail;
8359 if (arg2 == NULL) {
8360 SWIG_null_ref("wxFileSystem");
8361 }
8362 if (SWIG_arg_fail(2)) SWIG_fail;
8363 }
8364 {
8365 arg3 = wxString_in_helper(obj2);
8366 if (arg3 == NULL) SWIG_fail;
8367 temp3 = true;
8368 }
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8372
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 {
8377 resultobj = wxPyMake_wxObject(result, 1);
8378 }
8379 {
8380 if (temp3)
8381 delete arg3;
8382 }
8383 return resultobj;
8384 fail:
8385 {
8386 if (temp3)
8387 delete arg3;
8388 }
8389 return NULL;
8390 }
8391
8392
8393 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8394 PyObject *resultobj;
8395 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8396 wxString *arg2 = 0 ;
8397 int arg3 = (int) 0 ;
8398 wxString result;
8399 bool temp2 = false ;
8400 PyObject * obj0 = 0 ;
8401 PyObject * obj1 = 0 ;
8402 PyObject * obj2 = 0 ;
8403 char *kwnames[] = {
8404 (char *) "self",(char *) "spec",(char *) "flags", NULL
8405 };
8406
8407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8409 if (SWIG_arg_fail(1)) SWIG_fail;
8410 {
8411 arg2 = wxString_in_helper(obj1);
8412 if (arg2 == NULL) SWIG_fail;
8413 temp2 = true;
8414 }
8415 if (obj2) {
8416 {
8417 arg3 = (int)(SWIG_As_int(obj2));
8418 if (SWIG_arg_fail(3)) SWIG_fail;
8419 }
8420 }
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8424
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 {
8429 #if wxUSE_UNICODE
8430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8431 #else
8432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8433 #endif
8434 }
8435 {
8436 if (temp2)
8437 delete arg2;
8438 }
8439 return resultobj;
8440 fail:
8441 {
8442 if (temp2)
8443 delete arg2;
8444 }
8445 return NULL;
8446 }
8447
8448
8449 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8450 PyObject *resultobj;
8451 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8452 wxString result;
8453 PyObject * obj0 = 0 ;
8454 char *kwnames[] = {
8455 (char *) "self", NULL
8456 };
8457
8458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8460 if (SWIG_arg_fail(1)) SWIG_fail;
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 result = (arg1)->FindNext();
8464
8465 wxPyEndAllowThreads(__tstate);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 {
8469 #if wxUSE_UNICODE
8470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8471 #else
8472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8473 #endif
8474 }
8475 return resultobj;
8476 fail:
8477 return NULL;
8478 }
8479
8480
8481 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8482 PyObject *resultobj;
8483 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8484 wxString *arg2 = 0 ;
8485 wxString result;
8486 bool temp2 = false ;
8487 PyObject * obj0 = 0 ;
8488 PyObject * obj1 = 0 ;
8489 char *kwnames[] = {
8490 (char *) "self",(char *) "location", NULL
8491 };
8492
8493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8495 if (SWIG_arg_fail(1)) SWIG_fail;
8496 {
8497 arg2 = wxString_in_helper(obj1);
8498 if (arg2 == NULL) SWIG_fail;
8499 temp2 = true;
8500 }
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 result = (arg1)->GetProtocol((wxString const &)*arg2);
8504
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 {
8509 #if wxUSE_UNICODE
8510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8511 #else
8512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8513 #endif
8514 }
8515 {
8516 if (temp2)
8517 delete arg2;
8518 }
8519 return resultobj;
8520 fail:
8521 {
8522 if (temp2)
8523 delete arg2;
8524 }
8525 return NULL;
8526 }
8527
8528
8529 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8530 PyObject *resultobj;
8531 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8532 wxString *arg2 = 0 ;
8533 wxString result;
8534 bool temp2 = false ;
8535 PyObject * obj0 = 0 ;
8536 PyObject * obj1 = 0 ;
8537 char *kwnames[] = {
8538 (char *) "self",(char *) "location", NULL
8539 };
8540
8541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8543 if (SWIG_arg_fail(1)) SWIG_fail;
8544 {
8545 arg2 = wxString_in_helper(obj1);
8546 if (arg2 == NULL) SWIG_fail;
8547 temp2 = true;
8548 }
8549 {
8550 PyThreadState* __tstate = wxPyBeginAllowThreads();
8551 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8552
8553 wxPyEndAllowThreads(__tstate);
8554 if (PyErr_Occurred()) SWIG_fail;
8555 }
8556 {
8557 #if wxUSE_UNICODE
8558 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8559 #else
8560 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8561 #endif
8562 }
8563 {
8564 if (temp2)
8565 delete arg2;
8566 }
8567 return resultobj;
8568 fail:
8569 {
8570 if (temp2)
8571 delete arg2;
8572 }
8573 return NULL;
8574 }
8575
8576
8577 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj;
8579 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8580 wxString *arg2 = 0 ;
8581 wxString result;
8582 bool temp2 = false ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char *kwnames[] = {
8586 (char *) "self",(char *) "location", NULL
8587 };
8588
8589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8591 if (SWIG_arg_fail(1)) SWIG_fail;
8592 {
8593 arg2 = wxString_in_helper(obj1);
8594 if (arg2 == NULL) SWIG_fail;
8595 temp2 = true;
8596 }
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 result = (arg1)->GetAnchor((wxString const &)*arg2);
8600
8601 wxPyEndAllowThreads(__tstate);
8602 if (PyErr_Occurred()) SWIG_fail;
8603 }
8604 {
8605 #if wxUSE_UNICODE
8606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8607 #else
8608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8609 #endif
8610 }
8611 {
8612 if (temp2)
8613 delete arg2;
8614 }
8615 return resultobj;
8616 fail:
8617 {
8618 if (temp2)
8619 delete arg2;
8620 }
8621 return NULL;
8622 }
8623
8624
8625 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8626 PyObject *resultobj;
8627 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8628 wxString *arg2 = 0 ;
8629 wxString result;
8630 bool temp2 = false ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 char *kwnames[] = {
8634 (char *) "self",(char *) "location", NULL
8635 };
8636
8637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8639 if (SWIG_arg_fail(1)) SWIG_fail;
8640 {
8641 arg2 = wxString_in_helper(obj1);
8642 if (arg2 == NULL) SWIG_fail;
8643 temp2 = true;
8644 }
8645 {
8646 PyThreadState* __tstate = wxPyBeginAllowThreads();
8647 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8648
8649 wxPyEndAllowThreads(__tstate);
8650 if (PyErr_Occurred()) SWIG_fail;
8651 }
8652 {
8653 #if wxUSE_UNICODE
8654 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8655 #else
8656 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8657 #endif
8658 }
8659 {
8660 if (temp2)
8661 delete arg2;
8662 }
8663 return resultobj;
8664 fail:
8665 {
8666 if (temp2)
8667 delete arg2;
8668 }
8669 return NULL;
8670 }
8671
8672
8673 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8674 PyObject *resultobj;
8675 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8676 wxString *arg2 = 0 ;
8677 wxString result;
8678 bool temp2 = false ;
8679 PyObject * obj0 = 0 ;
8680 PyObject * obj1 = 0 ;
8681 char *kwnames[] = {
8682 (char *) "self",(char *) "location", NULL
8683 };
8684
8685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8687 if (SWIG_arg_fail(1)) SWIG_fail;
8688 {
8689 arg2 = wxString_in_helper(obj1);
8690 if (arg2 == NULL) SWIG_fail;
8691 temp2 = true;
8692 }
8693 {
8694 PyThreadState* __tstate = wxPyBeginAllowThreads();
8695 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8696
8697 wxPyEndAllowThreads(__tstate);
8698 if (PyErr_Occurred()) SWIG_fail;
8699 }
8700 {
8701 #if wxUSE_UNICODE
8702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8703 #else
8704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8705 #endif
8706 }
8707 {
8708 if (temp2)
8709 delete arg2;
8710 }
8711 return resultobj;
8712 fail:
8713 {
8714 if (temp2)
8715 delete arg2;
8716 }
8717 return NULL;
8718 }
8719
8720
8721 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8722 PyObject *obj;
8723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8724 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8725 Py_INCREF(obj);
8726 return Py_BuildValue((char *)"");
8727 }
8728 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8729 PyObject *resultobj;
8730 wxFileSystem *result;
8731 char *kwnames[] = {
8732 NULL
8733 };
8734
8735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8736 {
8737 PyThreadState* __tstate = wxPyBeginAllowThreads();
8738 result = (wxFileSystem *)new wxFileSystem();
8739
8740 wxPyEndAllowThreads(__tstate);
8741 if (PyErr_Occurred()) SWIG_fail;
8742 }
8743 {
8744 resultobj = wxPyMake_wxObject(result, 1);
8745 }
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8753 PyObject *resultobj;
8754 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8755 PyObject * obj0 = 0 ;
8756 char *kwnames[] = {
8757 (char *) "self", NULL
8758 };
8759
8760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8762 if (SWIG_arg_fail(1)) SWIG_fail;
8763 {
8764 PyThreadState* __tstate = wxPyBeginAllowThreads();
8765 delete arg1;
8766
8767 wxPyEndAllowThreads(__tstate);
8768 if (PyErr_Occurred()) SWIG_fail;
8769 }
8770 Py_INCREF(Py_None); resultobj = Py_None;
8771 return resultobj;
8772 fail:
8773 return NULL;
8774 }
8775
8776
8777 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8778 PyObject *resultobj;
8779 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8780 wxString *arg2 = 0 ;
8781 bool arg3 = (bool) false ;
8782 bool temp2 = false ;
8783 PyObject * obj0 = 0 ;
8784 PyObject * obj1 = 0 ;
8785 PyObject * obj2 = 0 ;
8786 char *kwnames[] = {
8787 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8788 };
8789
8790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8792 if (SWIG_arg_fail(1)) SWIG_fail;
8793 {
8794 arg2 = wxString_in_helper(obj1);
8795 if (arg2 == NULL) SWIG_fail;
8796 temp2 = true;
8797 }
8798 if (obj2) {
8799 {
8800 arg3 = (bool)(SWIG_As_bool(obj2));
8801 if (SWIG_arg_fail(3)) SWIG_fail;
8802 }
8803 }
8804 {
8805 PyThreadState* __tstate = wxPyBeginAllowThreads();
8806 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8807
8808 wxPyEndAllowThreads(__tstate);
8809 if (PyErr_Occurred()) SWIG_fail;
8810 }
8811 Py_INCREF(Py_None); resultobj = Py_None;
8812 {
8813 if (temp2)
8814 delete arg2;
8815 }
8816 return resultobj;
8817 fail:
8818 {
8819 if (temp2)
8820 delete arg2;
8821 }
8822 return NULL;
8823 }
8824
8825
8826 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8827 PyObject *resultobj;
8828 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8829 wxString result;
8830 PyObject * obj0 = 0 ;
8831 char *kwnames[] = {
8832 (char *) "self", NULL
8833 };
8834
8835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8837 if (SWIG_arg_fail(1)) SWIG_fail;
8838 {
8839 PyThreadState* __tstate = wxPyBeginAllowThreads();
8840 result = (arg1)->GetPath();
8841
8842 wxPyEndAllowThreads(__tstate);
8843 if (PyErr_Occurred()) SWIG_fail;
8844 }
8845 {
8846 #if wxUSE_UNICODE
8847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8848 #else
8849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8850 #endif
8851 }
8852 return resultobj;
8853 fail:
8854 return NULL;
8855 }
8856
8857
8858 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj;
8860 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8861 wxString *arg2 = 0 ;
8862 wxFSFile *result;
8863 bool temp2 = false ;
8864 PyObject * obj0 = 0 ;
8865 PyObject * obj1 = 0 ;
8866 char *kwnames[] = {
8867 (char *) "self",(char *) "location", NULL
8868 };
8869
8870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8872 if (SWIG_arg_fail(1)) SWIG_fail;
8873 {
8874 arg2 = wxString_in_helper(obj1);
8875 if (arg2 == NULL) SWIG_fail;
8876 temp2 = true;
8877 }
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 {
8886 resultobj = wxPyMake_wxObject(result, 1);
8887 }
8888 {
8889 if (temp2)
8890 delete arg2;
8891 }
8892 return resultobj;
8893 fail:
8894 {
8895 if (temp2)
8896 delete arg2;
8897 }
8898 return NULL;
8899 }
8900
8901
8902 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8903 PyObject *resultobj;
8904 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8905 wxString *arg2 = 0 ;
8906 int arg3 = (int) 0 ;
8907 wxString result;
8908 bool temp2 = false ;
8909 PyObject * obj0 = 0 ;
8910 PyObject * obj1 = 0 ;
8911 PyObject * obj2 = 0 ;
8912 char *kwnames[] = {
8913 (char *) "self",(char *) "spec",(char *) "flags", NULL
8914 };
8915
8916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8918 if (SWIG_arg_fail(1)) SWIG_fail;
8919 {
8920 arg2 = wxString_in_helper(obj1);
8921 if (arg2 == NULL) SWIG_fail;
8922 temp2 = true;
8923 }
8924 if (obj2) {
8925 {
8926 arg3 = (int)(SWIG_As_int(obj2));
8927 if (SWIG_arg_fail(3)) SWIG_fail;
8928 }
8929 }
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8933
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 {
8938 #if wxUSE_UNICODE
8939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8940 #else
8941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8942 #endif
8943 }
8944 {
8945 if (temp2)
8946 delete arg2;
8947 }
8948 return resultobj;
8949 fail:
8950 {
8951 if (temp2)
8952 delete arg2;
8953 }
8954 return NULL;
8955 }
8956
8957
8958 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8959 PyObject *resultobj;
8960 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8961 wxString result;
8962 PyObject * obj0 = 0 ;
8963 char *kwnames[] = {
8964 (char *) "self", NULL
8965 };
8966
8967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8969 if (SWIG_arg_fail(1)) SWIG_fail;
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 result = (arg1)->FindNext();
8973
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 {
8978 #if wxUSE_UNICODE
8979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8980 #else
8981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8982 #endif
8983 }
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8991 PyObject *resultobj;
8992 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8993 PyObject * obj0 = 0 ;
8994 char *kwnames[] = {
8995 (char *) "handler", NULL
8996 };
8997
8998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9000 if (SWIG_arg_fail(1)) SWIG_fail;
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 wxFileSystem::AddHandler(arg1);
9004
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 Py_INCREF(Py_None); resultobj = Py_None;
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9016 PyObject *resultobj;
9017 char *kwnames[] = {
9018 NULL
9019 };
9020
9021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 wxFileSystem::CleanUpHandlers();
9025
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 Py_INCREF(Py_None); resultobj = Py_None;
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9037 PyObject *resultobj;
9038 wxString *arg1 = 0 ;
9039 wxString result;
9040 bool temp1 = false ;
9041 PyObject * obj0 = 0 ;
9042 char *kwnames[] = {
9043 (char *) "filename", NULL
9044 };
9045
9046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9047 {
9048 arg1 = wxString_in_helper(obj0);
9049 if (arg1 == NULL) SWIG_fail;
9050 temp1 = true;
9051 }
9052 {
9053 PyThreadState* __tstate = wxPyBeginAllowThreads();
9054 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9055
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 {
9060 #if wxUSE_UNICODE
9061 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9062 #else
9063 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9064 #endif
9065 }
9066 {
9067 if (temp1)
9068 delete arg1;
9069 }
9070 return resultobj;
9071 fail:
9072 {
9073 if (temp1)
9074 delete arg1;
9075 }
9076 return NULL;
9077 }
9078
9079
9080 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9081 PyObject *resultobj;
9082 wxString *arg1 = 0 ;
9083 wxString result;
9084 bool temp1 = false ;
9085 PyObject * obj0 = 0 ;
9086 char *kwnames[] = {
9087 (char *) "url", NULL
9088 };
9089
9090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9091 {
9092 arg1 = wxString_in_helper(obj0);
9093 if (arg1 == NULL) SWIG_fail;
9094 temp1 = true;
9095 }
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 result = FileSystem_URLToFileName((wxString const &)*arg1);
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 {
9104 #if wxUSE_UNICODE
9105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9106 #else
9107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9108 #endif
9109 }
9110 {
9111 if (temp1)
9112 delete arg1;
9113 }
9114 return resultobj;
9115 fail:
9116 {
9117 if (temp1)
9118 delete arg1;
9119 }
9120 return NULL;
9121 }
9122
9123
9124 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9125 PyObject *obj;
9126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9127 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9128 Py_INCREF(obj);
9129 return Py_BuildValue((char *)"");
9130 }
9131 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9132 PyObject *resultobj;
9133 wxInternetFSHandler *result;
9134 char *kwnames[] = {
9135 NULL
9136 };
9137
9138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9139 {
9140 PyThreadState* __tstate = wxPyBeginAllowThreads();
9141 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9142
9143 wxPyEndAllowThreads(__tstate);
9144 if (PyErr_Occurred()) SWIG_fail;
9145 }
9146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9147 return resultobj;
9148 fail:
9149 return NULL;
9150 }
9151
9152
9153 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9154 PyObject *resultobj;
9155 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9156 wxString *arg2 = 0 ;
9157 bool result;
9158 bool temp2 = false ;
9159 PyObject * obj0 = 0 ;
9160 PyObject * obj1 = 0 ;
9161 char *kwnames[] = {
9162 (char *) "self",(char *) "location", NULL
9163 };
9164
9165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9167 if (SWIG_arg_fail(1)) SWIG_fail;
9168 {
9169 arg2 = wxString_in_helper(obj1);
9170 if (arg2 == NULL) SWIG_fail;
9171 temp2 = true;
9172 }
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9176
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 {
9181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9182 }
9183 {
9184 if (temp2)
9185 delete arg2;
9186 }
9187 return resultobj;
9188 fail:
9189 {
9190 if (temp2)
9191 delete arg2;
9192 }
9193 return NULL;
9194 }
9195
9196
9197 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj;
9199 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9200 wxFileSystem *arg2 = 0 ;
9201 wxString *arg3 = 0 ;
9202 wxFSFile *result;
9203 bool temp3 = false ;
9204 PyObject * obj0 = 0 ;
9205 PyObject * obj1 = 0 ;
9206 PyObject * obj2 = 0 ;
9207 char *kwnames[] = {
9208 (char *) "self",(char *) "fs",(char *) "location", NULL
9209 };
9210
9211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9213 if (SWIG_arg_fail(1)) SWIG_fail;
9214 {
9215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9216 if (SWIG_arg_fail(2)) SWIG_fail;
9217 if (arg2 == NULL) {
9218 SWIG_null_ref("wxFileSystem");
9219 }
9220 if (SWIG_arg_fail(2)) SWIG_fail;
9221 }
9222 {
9223 arg3 = wxString_in_helper(obj2);
9224 if (arg3 == NULL) SWIG_fail;
9225 temp3 = true;
9226 }
9227 {
9228 PyThreadState* __tstate = wxPyBeginAllowThreads();
9229 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9230
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 {
9235 resultobj = wxPyMake_wxObject(result, 1);
9236 }
9237 {
9238 if (temp3)
9239 delete arg3;
9240 }
9241 return resultobj;
9242 fail:
9243 {
9244 if (temp3)
9245 delete arg3;
9246 }
9247 return NULL;
9248 }
9249
9250
9251 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9252 PyObject *obj;
9253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9254 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9255 Py_INCREF(obj);
9256 return Py_BuildValue((char *)"");
9257 }
9258 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9259 PyObject *resultobj;
9260 wxZipFSHandler *result;
9261 char *kwnames[] = {
9262 NULL
9263 };
9264
9265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9266 {
9267 PyThreadState* __tstate = wxPyBeginAllowThreads();
9268 result = (wxZipFSHandler *)new wxZipFSHandler();
9269
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9274 return resultobj;
9275 fail:
9276 return NULL;
9277 }
9278
9279
9280 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj;
9282 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9283 wxString *arg2 = 0 ;
9284 bool result;
9285 bool temp2 = false ;
9286 PyObject * obj0 = 0 ;
9287 PyObject * obj1 = 0 ;
9288 char *kwnames[] = {
9289 (char *) "self",(char *) "location", NULL
9290 };
9291
9292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9294 if (SWIG_arg_fail(1)) SWIG_fail;
9295 {
9296 arg2 = wxString_in_helper(obj1);
9297 if (arg2 == NULL) SWIG_fail;
9298 temp2 = true;
9299 }
9300 {
9301 PyThreadState* __tstate = wxPyBeginAllowThreads();
9302 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9303
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 {
9308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9309 }
9310 {
9311 if (temp2)
9312 delete arg2;
9313 }
9314 return resultobj;
9315 fail:
9316 {
9317 if (temp2)
9318 delete arg2;
9319 }
9320 return NULL;
9321 }
9322
9323
9324 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9325 PyObject *resultobj;
9326 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9327 wxFileSystem *arg2 = 0 ;
9328 wxString *arg3 = 0 ;
9329 wxFSFile *result;
9330 bool temp3 = false ;
9331 PyObject * obj0 = 0 ;
9332 PyObject * obj1 = 0 ;
9333 PyObject * obj2 = 0 ;
9334 char *kwnames[] = {
9335 (char *) "self",(char *) "fs",(char *) "location", NULL
9336 };
9337
9338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9340 if (SWIG_arg_fail(1)) SWIG_fail;
9341 {
9342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9343 if (SWIG_arg_fail(2)) SWIG_fail;
9344 if (arg2 == NULL) {
9345 SWIG_null_ref("wxFileSystem");
9346 }
9347 if (SWIG_arg_fail(2)) SWIG_fail;
9348 }
9349 {
9350 arg3 = wxString_in_helper(obj2);
9351 if (arg3 == NULL) SWIG_fail;
9352 temp3 = true;
9353 }
9354 {
9355 PyThreadState* __tstate = wxPyBeginAllowThreads();
9356 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9357
9358 wxPyEndAllowThreads(__tstate);
9359 if (PyErr_Occurred()) SWIG_fail;
9360 }
9361 {
9362 resultobj = wxPyMake_wxObject(result, 1);
9363 }
9364 {
9365 if (temp3)
9366 delete arg3;
9367 }
9368 return resultobj;
9369 fail:
9370 {
9371 if (temp3)
9372 delete arg3;
9373 }
9374 return NULL;
9375 }
9376
9377
9378 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9379 PyObject *resultobj;
9380 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9381 wxString *arg2 = 0 ;
9382 int arg3 = (int) 0 ;
9383 wxString result;
9384 bool temp2 = false ;
9385 PyObject * obj0 = 0 ;
9386 PyObject * obj1 = 0 ;
9387 PyObject * obj2 = 0 ;
9388 char *kwnames[] = {
9389 (char *) "self",(char *) "spec",(char *) "flags", NULL
9390 };
9391
9392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9394 if (SWIG_arg_fail(1)) SWIG_fail;
9395 {
9396 arg2 = wxString_in_helper(obj1);
9397 if (arg2 == NULL) SWIG_fail;
9398 temp2 = true;
9399 }
9400 if (obj2) {
9401 {
9402 arg3 = (int)(SWIG_As_int(obj2));
9403 if (SWIG_arg_fail(3)) SWIG_fail;
9404 }
9405 }
9406 {
9407 PyThreadState* __tstate = wxPyBeginAllowThreads();
9408 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9409
9410 wxPyEndAllowThreads(__tstate);
9411 if (PyErr_Occurred()) SWIG_fail;
9412 }
9413 {
9414 #if wxUSE_UNICODE
9415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9416 #else
9417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9418 #endif
9419 }
9420 {
9421 if (temp2)
9422 delete arg2;
9423 }
9424 return resultobj;
9425 fail:
9426 {
9427 if (temp2)
9428 delete arg2;
9429 }
9430 return NULL;
9431 }
9432
9433
9434 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj;
9436 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9437 wxString result;
9438 PyObject * obj0 = 0 ;
9439 char *kwnames[] = {
9440 (char *) "self", NULL
9441 };
9442
9443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9445 if (SWIG_arg_fail(1)) SWIG_fail;
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 result = (arg1)->FindNext();
9449
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 {
9454 #if wxUSE_UNICODE
9455 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9456 #else
9457 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9458 #endif
9459 }
9460 return resultobj;
9461 fail:
9462 return NULL;
9463 }
9464
9465
9466 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9467 PyObject *obj;
9468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9469 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9470 Py_INCREF(obj);
9471 return Py_BuildValue((char *)"");
9472 }
9473 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9474 PyObject *resultobj;
9475 wxString *arg1 = 0 ;
9476 wxImage *arg2 = 0 ;
9477 long arg3 ;
9478 bool temp1 = false ;
9479 PyObject * obj0 = 0 ;
9480 PyObject * obj1 = 0 ;
9481 PyObject * obj2 = 0 ;
9482 char *kwnames[] = {
9483 (char *) "filename",(char *) "image",(char *) "type", NULL
9484 };
9485
9486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9487 {
9488 arg1 = wxString_in_helper(obj0);
9489 if (arg1 == NULL) SWIG_fail;
9490 temp1 = true;
9491 }
9492 {
9493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9494 if (SWIG_arg_fail(2)) SWIG_fail;
9495 if (arg2 == NULL) {
9496 SWIG_null_ref("wxImage");
9497 }
9498 if (SWIG_arg_fail(2)) SWIG_fail;
9499 }
9500 {
9501 arg3 = (long)(SWIG_As_long(obj2));
9502 if (SWIG_arg_fail(3)) SWIG_fail;
9503 }
9504 {
9505 PyThreadState* __tstate = wxPyBeginAllowThreads();
9506 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9507
9508 wxPyEndAllowThreads(__tstate);
9509 if (PyErr_Occurred()) SWIG_fail;
9510 }
9511 Py_INCREF(Py_None); resultobj = Py_None;
9512 {
9513 if (temp1)
9514 delete arg1;
9515 }
9516 return resultobj;
9517 fail:
9518 {
9519 if (temp1)
9520 delete arg1;
9521 }
9522 return NULL;
9523 }
9524
9525
9526 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9527 PyObject *resultobj;
9528 wxString *arg1 = 0 ;
9529 wxBitmap *arg2 = 0 ;
9530 long arg3 ;
9531 bool temp1 = false ;
9532 PyObject * obj0 = 0 ;
9533 PyObject * obj1 = 0 ;
9534 PyObject * obj2 = 0 ;
9535 char *kwnames[] = {
9536 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9537 };
9538
9539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9540 {
9541 arg1 = wxString_in_helper(obj0);
9542 if (arg1 == NULL) SWIG_fail;
9543 temp1 = true;
9544 }
9545 {
9546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9547 if (SWIG_arg_fail(2)) SWIG_fail;
9548 if (arg2 == NULL) {
9549 SWIG_null_ref("wxBitmap");
9550 }
9551 if (SWIG_arg_fail(2)) SWIG_fail;
9552 }
9553 {
9554 arg3 = (long)(SWIG_As_long(obj2));
9555 if (SWIG_arg_fail(3)) SWIG_fail;
9556 }
9557 {
9558 PyThreadState* __tstate = wxPyBeginAllowThreads();
9559 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9560
9561 wxPyEndAllowThreads(__tstate);
9562 if (PyErr_Occurred()) SWIG_fail;
9563 }
9564 Py_INCREF(Py_None); resultobj = Py_None;
9565 {
9566 if (temp1)
9567 delete arg1;
9568 }
9569 return resultobj;
9570 fail:
9571 {
9572 if (temp1)
9573 delete arg1;
9574 }
9575 return NULL;
9576 }
9577
9578
9579 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9580 PyObject *resultobj;
9581 wxString *arg1 = 0 ;
9582 PyObject *arg2 = (PyObject *) 0 ;
9583 bool temp1 = false ;
9584 PyObject * obj0 = 0 ;
9585 PyObject * obj1 = 0 ;
9586 char *kwnames[] = {
9587 (char *) "filename",(char *) "data", NULL
9588 };
9589
9590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9591 {
9592 arg1 = wxString_in_helper(obj0);
9593 if (arg1 == NULL) SWIG_fail;
9594 temp1 = true;
9595 }
9596 arg2 = obj1;
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9600
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 Py_INCREF(Py_None); resultobj = Py_None;
9605 {
9606 if (temp1)
9607 delete arg1;
9608 }
9609 return resultobj;
9610 fail:
9611 {
9612 if (temp1)
9613 delete arg1;
9614 }
9615 return NULL;
9616 }
9617
9618
9619 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9620 PyObject *resultobj;
9621 wxMemoryFSHandler *result;
9622 char *kwnames[] = {
9623 NULL
9624 };
9625
9626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9627 {
9628 PyThreadState* __tstate = wxPyBeginAllowThreads();
9629 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9630
9631 wxPyEndAllowThreads(__tstate);
9632 if (PyErr_Occurred()) SWIG_fail;
9633 }
9634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9635 return resultobj;
9636 fail:
9637 return NULL;
9638 }
9639
9640
9641 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9642 PyObject *resultobj;
9643 wxString *arg1 = 0 ;
9644 bool temp1 = false ;
9645 PyObject * obj0 = 0 ;
9646 char *kwnames[] = {
9647 (char *) "filename", NULL
9648 };
9649
9650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9651 {
9652 arg1 = wxString_in_helper(obj0);
9653 if (arg1 == NULL) SWIG_fail;
9654 temp1 = true;
9655 }
9656 {
9657 PyThreadState* __tstate = wxPyBeginAllowThreads();
9658 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9659
9660 wxPyEndAllowThreads(__tstate);
9661 if (PyErr_Occurred()) SWIG_fail;
9662 }
9663 Py_INCREF(Py_None); resultobj = Py_None;
9664 {
9665 if (temp1)
9666 delete arg1;
9667 }
9668 return resultobj;
9669 fail:
9670 {
9671 if (temp1)
9672 delete arg1;
9673 }
9674 return NULL;
9675 }
9676
9677
9678 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9679 PyObject *resultobj;
9680 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9681 wxString *arg2 = 0 ;
9682 bool result;
9683 bool temp2 = false ;
9684 PyObject * obj0 = 0 ;
9685 PyObject * obj1 = 0 ;
9686 char *kwnames[] = {
9687 (char *) "self",(char *) "location", NULL
9688 };
9689
9690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9692 if (SWIG_arg_fail(1)) SWIG_fail;
9693 {
9694 arg2 = wxString_in_helper(obj1);
9695 if (arg2 == NULL) SWIG_fail;
9696 temp2 = true;
9697 }
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9701
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 {
9706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9707 }
9708 {
9709 if (temp2)
9710 delete arg2;
9711 }
9712 return resultobj;
9713 fail:
9714 {
9715 if (temp2)
9716 delete arg2;
9717 }
9718 return NULL;
9719 }
9720
9721
9722 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9723 PyObject *resultobj;
9724 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9725 wxFileSystem *arg2 = 0 ;
9726 wxString *arg3 = 0 ;
9727 wxFSFile *result;
9728 bool temp3 = false ;
9729 PyObject * obj0 = 0 ;
9730 PyObject * obj1 = 0 ;
9731 PyObject * obj2 = 0 ;
9732 char *kwnames[] = {
9733 (char *) "self",(char *) "fs",(char *) "location", NULL
9734 };
9735
9736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9738 if (SWIG_arg_fail(1)) SWIG_fail;
9739 {
9740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9741 if (SWIG_arg_fail(2)) SWIG_fail;
9742 if (arg2 == NULL) {
9743 SWIG_null_ref("wxFileSystem");
9744 }
9745 if (SWIG_arg_fail(2)) SWIG_fail;
9746 }
9747 {
9748 arg3 = wxString_in_helper(obj2);
9749 if (arg3 == NULL) SWIG_fail;
9750 temp3 = true;
9751 }
9752 {
9753 PyThreadState* __tstate = wxPyBeginAllowThreads();
9754 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9755
9756 wxPyEndAllowThreads(__tstate);
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 {
9760 resultobj = wxPyMake_wxObject(result, 1);
9761 }
9762 {
9763 if (temp3)
9764 delete arg3;
9765 }
9766 return resultobj;
9767 fail:
9768 {
9769 if (temp3)
9770 delete arg3;
9771 }
9772 return NULL;
9773 }
9774
9775
9776 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9777 PyObject *resultobj;
9778 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9779 wxString *arg2 = 0 ;
9780 int arg3 = (int) 0 ;
9781 wxString result;
9782 bool temp2 = false ;
9783 PyObject * obj0 = 0 ;
9784 PyObject * obj1 = 0 ;
9785 PyObject * obj2 = 0 ;
9786 char *kwnames[] = {
9787 (char *) "self",(char *) "spec",(char *) "flags", NULL
9788 };
9789
9790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9792 if (SWIG_arg_fail(1)) SWIG_fail;
9793 {
9794 arg2 = wxString_in_helper(obj1);
9795 if (arg2 == NULL) SWIG_fail;
9796 temp2 = true;
9797 }
9798 if (obj2) {
9799 {
9800 arg3 = (int)(SWIG_As_int(obj2));
9801 if (SWIG_arg_fail(3)) SWIG_fail;
9802 }
9803 }
9804 {
9805 PyThreadState* __tstate = wxPyBeginAllowThreads();
9806 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9807
9808 wxPyEndAllowThreads(__tstate);
9809 if (PyErr_Occurred()) SWIG_fail;
9810 }
9811 {
9812 #if wxUSE_UNICODE
9813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9814 #else
9815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9816 #endif
9817 }
9818 {
9819 if (temp2)
9820 delete arg2;
9821 }
9822 return resultobj;
9823 fail:
9824 {
9825 if (temp2)
9826 delete arg2;
9827 }
9828 return NULL;
9829 }
9830
9831
9832 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9833 PyObject *resultobj;
9834 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9835 wxString result;
9836 PyObject * obj0 = 0 ;
9837 char *kwnames[] = {
9838 (char *) "self", NULL
9839 };
9840
9841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9843 if (SWIG_arg_fail(1)) SWIG_fail;
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = (arg1)->FindNext();
9847
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 #if wxUSE_UNICODE
9853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9854 #else
9855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9856 #endif
9857 }
9858 return resultobj;
9859 fail:
9860 return NULL;
9861 }
9862
9863
9864 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9865 PyObject *obj;
9866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9867 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9868 Py_INCREF(obj);
9869 return Py_BuildValue((char *)"");
9870 }
9871 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj;
9873 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9874 wxString result;
9875 PyObject * obj0 = 0 ;
9876 char *kwnames[] = {
9877 (char *) "self", NULL
9878 };
9879
9880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9882 if (SWIG_arg_fail(1)) SWIG_fail;
9883 {
9884 PyThreadState* __tstate = wxPyBeginAllowThreads();
9885 result = (arg1)->GetName();
9886
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 {
9891 #if wxUSE_UNICODE
9892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9893 #else
9894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9895 #endif
9896 }
9897 return resultobj;
9898 fail:
9899 return NULL;
9900 }
9901
9902
9903 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9904 PyObject *resultobj;
9905 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9906 wxString result;
9907 PyObject * obj0 = 0 ;
9908 char *kwnames[] = {
9909 (char *) "self", NULL
9910 };
9911
9912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9914 if (SWIG_arg_fail(1)) SWIG_fail;
9915 {
9916 PyThreadState* __tstate = wxPyBeginAllowThreads();
9917 result = (arg1)->GetExtension();
9918
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 {
9923 #if wxUSE_UNICODE
9924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9925 #else
9926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9927 #endif
9928 }
9929 return resultobj;
9930 fail:
9931 return NULL;
9932 }
9933
9934
9935 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9936 PyObject *resultobj;
9937 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9938 long result;
9939 PyObject * obj0 = 0 ;
9940 char *kwnames[] = {
9941 (char *) "self", NULL
9942 };
9943
9944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9946 if (SWIG_arg_fail(1)) SWIG_fail;
9947 {
9948 PyThreadState* __tstate = wxPyBeginAllowThreads();
9949 result = (long)(arg1)->GetType();
9950
9951 wxPyEndAllowThreads(__tstate);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 {
9955 resultobj = SWIG_From_long((long)(result));
9956 }
9957 return resultobj;
9958 fail:
9959 return NULL;
9960 }
9961
9962
9963 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9964 PyObject *resultobj;
9965 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9966 wxString result;
9967 PyObject * obj0 = 0 ;
9968 char *kwnames[] = {
9969 (char *) "self", NULL
9970 };
9971
9972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9974 if (SWIG_arg_fail(1)) SWIG_fail;
9975 {
9976 PyThreadState* __tstate = wxPyBeginAllowThreads();
9977 result = (arg1)->GetMimeType();
9978
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 {
9983 #if wxUSE_UNICODE
9984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9985 #else
9986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9987 #endif
9988 }
9989 return resultobj;
9990 fail:
9991 return NULL;
9992 }
9993
9994
9995 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9996 PyObject *resultobj;
9997 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9998 wxString *arg2 = 0 ;
9999 bool result;
10000 bool temp2 = false ;
10001 PyObject * obj0 = 0 ;
10002 PyObject * obj1 = 0 ;
10003 char *kwnames[] = {
10004 (char *) "self",(char *) "name", NULL
10005 };
10006
10007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10009 if (SWIG_arg_fail(1)) SWIG_fail;
10010 {
10011 arg2 = wxString_in_helper(obj1);
10012 if (arg2 == NULL) SWIG_fail;
10013 temp2 = true;
10014 }
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10018
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 {
10023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10024 }
10025 {
10026 if (temp2)
10027 delete arg2;
10028 }
10029 return resultobj;
10030 fail:
10031 {
10032 if (temp2)
10033 delete arg2;
10034 }
10035 return NULL;
10036 }
10037
10038
10039 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10040 PyObject *resultobj;
10041 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10042 wxString *arg2 = 0 ;
10043 bool temp2 = false ;
10044 PyObject * obj0 = 0 ;
10045 PyObject * obj1 = 0 ;
10046 char *kwnames[] = {
10047 (char *) "self",(char *) "name", NULL
10048 };
10049
10050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10052 if (SWIG_arg_fail(1)) SWIG_fail;
10053 {
10054 arg2 = wxString_in_helper(obj1);
10055 if (arg2 == NULL) SWIG_fail;
10056 temp2 = true;
10057 }
10058 {
10059 PyThreadState* __tstate = wxPyBeginAllowThreads();
10060 (arg1)->SetName((wxString const &)*arg2);
10061
10062 wxPyEndAllowThreads(__tstate);
10063 if (PyErr_Occurred()) SWIG_fail;
10064 }
10065 Py_INCREF(Py_None); resultobj = Py_None;
10066 {
10067 if (temp2)
10068 delete arg2;
10069 }
10070 return resultobj;
10071 fail:
10072 {
10073 if (temp2)
10074 delete arg2;
10075 }
10076 return NULL;
10077 }
10078
10079
10080 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10081 PyObject *resultobj;
10082 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10083 wxString *arg2 = 0 ;
10084 bool temp2 = false ;
10085 PyObject * obj0 = 0 ;
10086 PyObject * obj1 = 0 ;
10087 char *kwnames[] = {
10088 (char *) "self",(char *) "extension", NULL
10089 };
10090
10091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10093 if (SWIG_arg_fail(1)) SWIG_fail;
10094 {
10095 arg2 = wxString_in_helper(obj1);
10096 if (arg2 == NULL) SWIG_fail;
10097 temp2 = true;
10098 }
10099 {
10100 PyThreadState* __tstate = wxPyBeginAllowThreads();
10101 (arg1)->SetExtension((wxString const &)*arg2);
10102
10103 wxPyEndAllowThreads(__tstate);
10104 if (PyErr_Occurred()) SWIG_fail;
10105 }
10106 Py_INCREF(Py_None); resultobj = Py_None;
10107 {
10108 if (temp2)
10109 delete arg2;
10110 }
10111 return resultobj;
10112 fail:
10113 {
10114 if (temp2)
10115 delete arg2;
10116 }
10117 return NULL;
10118 }
10119
10120
10121 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10122 PyObject *resultobj;
10123 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10124 long arg2 ;
10125 PyObject * obj0 = 0 ;
10126 PyObject * obj1 = 0 ;
10127 char *kwnames[] = {
10128 (char *) "self",(char *) "type", NULL
10129 };
10130
10131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10133 if (SWIG_arg_fail(1)) SWIG_fail;
10134 {
10135 arg2 = (long)(SWIG_As_long(obj1));
10136 if (SWIG_arg_fail(2)) SWIG_fail;
10137 }
10138 {
10139 PyThreadState* __tstate = wxPyBeginAllowThreads();
10140 (arg1)->SetType(arg2);
10141
10142 wxPyEndAllowThreads(__tstate);
10143 if (PyErr_Occurred()) SWIG_fail;
10144 }
10145 Py_INCREF(Py_None); resultobj = Py_None;
10146 return resultobj;
10147 fail:
10148 return NULL;
10149 }
10150
10151
10152 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10153 PyObject *resultobj;
10154 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10155 wxString *arg2 = 0 ;
10156 bool temp2 = false ;
10157 PyObject * obj0 = 0 ;
10158 PyObject * obj1 = 0 ;
10159 char *kwnames[] = {
10160 (char *) "self",(char *) "mimetype", NULL
10161 };
10162
10163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10165 if (SWIG_arg_fail(1)) SWIG_fail;
10166 {
10167 arg2 = wxString_in_helper(obj1);
10168 if (arg2 == NULL) SWIG_fail;
10169 temp2 = true;
10170 }
10171 {
10172 PyThreadState* __tstate = wxPyBeginAllowThreads();
10173 (arg1)->SetMimeType((wxString const &)*arg2);
10174
10175 wxPyEndAllowThreads(__tstate);
10176 if (PyErr_Occurred()) SWIG_fail;
10177 }
10178 Py_INCREF(Py_None); resultobj = Py_None;
10179 {
10180 if (temp2)
10181 delete arg2;
10182 }
10183 return resultobj;
10184 fail:
10185 {
10186 if (temp2)
10187 delete arg2;
10188 }
10189 return NULL;
10190 }
10191
10192
10193 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10194 PyObject *obj;
10195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10196 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10197 Py_INCREF(obj);
10198 return Py_BuildValue((char *)"");
10199 }
10200 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10201 PyObject *resultobj;
10202 wxImageHistogram *result;
10203 char *kwnames[] = {
10204 NULL
10205 };
10206
10207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10208 {
10209 PyThreadState* __tstate = wxPyBeginAllowThreads();
10210 result = (wxImageHistogram *)new wxImageHistogram();
10211
10212 wxPyEndAllowThreads(__tstate);
10213 if (PyErr_Occurred()) SWIG_fail;
10214 }
10215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10216 return resultobj;
10217 fail:
10218 return NULL;
10219 }
10220
10221
10222 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10223 PyObject *resultobj;
10224 unsigned char arg1 ;
10225 unsigned char arg2 ;
10226 unsigned char arg3 ;
10227 unsigned long result;
10228 PyObject * obj0 = 0 ;
10229 PyObject * obj1 = 0 ;
10230 PyObject * obj2 = 0 ;
10231 char *kwnames[] = {
10232 (char *) "r",(char *) "g",(char *) "b", NULL
10233 };
10234
10235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10236 {
10237 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10238 if (SWIG_arg_fail(1)) SWIG_fail;
10239 }
10240 {
10241 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10242 if (SWIG_arg_fail(2)) SWIG_fail;
10243 }
10244 {
10245 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10246 if (SWIG_arg_fail(3)) SWIG_fail;
10247 }
10248 {
10249 PyThreadState* __tstate = wxPyBeginAllowThreads();
10250 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10251
10252 wxPyEndAllowThreads(__tstate);
10253 if (PyErr_Occurred()) SWIG_fail;
10254 }
10255 {
10256 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10257 }
10258 return resultobj;
10259 fail:
10260 return NULL;
10261 }
10262
10263
10264 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10265 PyObject *resultobj;
10266 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10267 unsigned char *arg2 = (unsigned char *) 0 ;
10268 unsigned char *arg3 = (unsigned char *) 0 ;
10269 unsigned char *arg4 = (unsigned char *) 0 ;
10270 unsigned char arg5 = (unsigned char) 1 ;
10271 unsigned char arg6 = (unsigned char) 0 ;
10272 unsigned char arg7 = (unsigned char) 0 ;
10273 bool result;
10274 unsigned char temp2 ;
10275 int res2 = 0 ;
10276 unsigned char temp3 ;
10277 int res3 = 0 ;
10278 unsigned char temp4 ;
10279 int res4 = 0 ;
10280 PyObject * obj0 = 0 ;
10281 PyObject * obj1 = 0 ;
10282 PyObject * obj2 = 0 ;
10283 PyObject * obj3 = 0 ;
10284 char *kwnames[] = {
10285 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10286 };
10287
10288 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10289 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10290 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10293 if (SWIG_arg_fail(1)) SWIG_fail;
10294 if (obj1) {
10295 {
10296 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10297 if (SWIG_arg_fail(5)) SWIG_fail;
10298 }
10299 }
10300 if (obj2) {
10301 {
10302 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10303 if (SWIG_arg_fail(6)) SWIG_fail;
10304 }
10305 }
10306 if (obj3) {
10307 {
10308 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10309 if (SWIG_arg_fail(7)) SWIG_fail;
10310 }
10311 }
10312 {
10313 PyThreadState* __tstate = wxPyBeginAllowThreads();
10314 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10315
10316 wxPyEndAllowThreads(__tstate);
10317 if (PyErr_Occurred()) SWIG_fail;
10318 }
10319 {
10320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10321 }
10322 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10323 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10324 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10325 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10326 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10327 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10328 return resultobj;
10329 fail:
10330 return NULL;
10331 }
10332
10333
10334 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj;
10336 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10337 unsigned long arg2 ;
10338 unsigned long result;
10339 PyObject * obj0 = 0 ;
10340 PyObject * obj1 = 0 ;
10341 char *kwnames[] = {
10342 (char *) "self",(char *) "key", NULL
10343 };
10344
10345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10347 if (SWIG_arg_fail(1)) SWIG_fail;
10348 {
10349 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10350 if (SWIG_arg_fail(2)) SWIG_fail;
10351 }
10352 {
10353 PyThreadState* __tstate = wxPyBeginAllowThreads();
10354 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10355
10356 wxPyEndAllowThreads(__tstate);
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 {
10360 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10361 }
10362 return resultobj;
10363 fail:
10364 return NULL;
10365 }
10366
10367
10368 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10369 PyObject *resultobj;
10370 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10371 unsigned char arg2 ;
10372 unsigned char arg3 ;
10373 unsigned char arg4 ;
10374 unsigned long result;
10375 PyObject * obj0 = 0 ;
10376 PyObject * obj1 = 0 ;
10377 PyObject * obj2 = 0 ;
10378 PyObject * obj3 = 0 ;
10379 char *kwnames[] = {
10380 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10381 };
10382
10383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10385 if (SWIG_arg_fail(1)) SWIG_fail;
10386 {
10387 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10388 if (SWIG_arg_fail(2)) SWIG_fail;
10389 }
10390 {
10391 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10392 if (SWIG_arg_fail(3)) SWIG_fail;
10393 }
10394 {
10395 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10396 if (SWIG_arg_fail(4)) SWIG_fail;
10397 }
10398 {
10399 PyThreadState* __tstate = wxPyBeginAllowThreads();
10400 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10401
10402 wxPyEndAllowThreads(__tstate);
10403 if (PyErr_Occurred()) SWIG_fail;
10404 }
10405 {
10406 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10407 }
10408 return resultobj;
10409 fail:
10410 return NULL;
10411 }
10412
10413
10414 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10415 PyObject *resultobj;
10416 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10417 wxColour *arg2 = 0 ;
10418 unsigned long result;
10419 wxColour temp2 ;
10420 PyObject * obj0 = 0 ;
10421 PyObject * obj1 = 0 ;
10422 char *kwnames[] = {
10423 (char *) "self",(char *) "colour", NULL
10424 };
10425
10426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10428 if (SWIG_arg_fail(1)) SWIG_fail;
10429 {
10430 arg2 = &temp2;
10431 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10432 }
10433 {
10434 PyThreadState* __tstate = wxPyBeginAllowThreads();
10435 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10436
10437 wxPyEndAllowThreads(__tstate);
10438 if (PyErr_Occurred()) SWIG_fail;
10439 }
10440 {
10441 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10442 }
10443 return resultobj;
10444 fail:
10445 return NULL;
10446 }
10447
10448
10449 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10450 PyObject *obj;
10451 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10452 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10453 Py_INCREF(obj);
10454 return Py_BuildValue((char *)"");
10455 }
10456 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10457 PyObject *resultobj;
10458 wxString *arg1 = 0 ;
10459 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10460 int arg3 = (int) -1 ;
10461 wxImage *result;
10462 bool temp1 = false ;
10463 PyObject * obj0 = 0 ;
10464 PyObject * obj1 = 0 ;
10465 PyObject * obj2 = 0 ;
10466 char *kwnames[] = {
10467 (char *) "name",(char *) "type",(char *) "index", NULL
10468 };
10469
10470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10471 {
10472 arg1 = wxString_in_helper(obj0);
10473 if (arg1 == NULL) SWIG_fail;
10474 temp1 = true;
10475 }
10476 if (obj1) {
10477 {
10478 arg2 = (long)(SWIG_As_long(obj1));
10479 if (SWIG_arg_fail(2)) SWIG_fail;
10480 }
10481 }
10482 if (obj2) {
10483 {
10484 arg3 = (int)(SWIG_As_int(obj2));
10485 if (SWIG_arg_fail(3)) SWIG_fail;
10486 }
10487 }
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10491
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10496 {
10497 if (temp1)
10498 delete arg1;
10499 }
10500 return resultobj;
10501 fail:
10502 {
10503 if (temp1)
10504 delete arg1;
10505 }
10506 return NULL;
10507 }
10508
10509
10510 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10511 PyObject *resultobj;
10512 wxImage *arg1 = (wxImage *) 0 ;
10513 PyObject * obj0 = 0 ;
10514 char *kwnames[] = {
10515 (char *) "self", NULL
10516 };
10517
10518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10520 if (SWIG_arg_fail(1)) SWIG_fail;
10521 {
10522 PyThreadState* __tstate = wxPyBeginAllowThreads();
10523 delete arg1;
10524
10525 wxPyEndAllowThreads(__tstate);
10526 if (PyErr_Occurred()) SWIG_fail;
10527 }
10528 Py_INCREF(Py_None); resultobj = Py_None;
10529 return resultobj;
10530 fail:
10531 return NULL;
10532 }
10533
10534
10535 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10536 PyObject *resultobj;
10537 wxString *arg1 = 0 ;
10538 wxString *arg2 = 0 ;
10539 int arg3 = (int) -1 ;
10540 wxImage *result;
10541 bool temp1 = false ;
10542 bool temp2 = false ;
10543 PyObject * obj0 = 0 ;
10544 PyObject * obj1 = 0 ;
10545 PyObject * obj2 = 0 ;
10546 char *kwnames[] = {
10547 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10548 };
10549
10550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10551 {
10552 arg1 = wxString_in_helper(obj0);
10553 if (arg1 == NULL) SWIG_fail;
10554 temp1 = true;
10555 }
10556 {
10557 arg2 = wxString_in_helper(obj1);
10558 if (arg2 == NULL) SWIG_fail;
10559 temp2 = true;
10560 }
10561 if (obj2) {
10562 {
10563 arg3 = (int)(SWIG_As_int(obj2));
10564 if (SWIG_arg_fail(3)) SWIG_fail;
10565 }
10566 }
10567 {
10568 PyThreadState* __tstate = wxPyBeginAllowThreads();
10569 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10570
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10575 {
10576 if (temp1)
10577 delete arg1;
10578 }
10579 {
10580 if (temp2)
10581 delete arg2;
10582 }
10583 return resultobj;
10584 fail:
10585 {
10586 if (temp1)
10587 delete arg1;
10588 }
10589 {
10590 if (temp2)
10591 delete arg2;
10592 }
10593 return NULL;
10594 }
10595
10596
10597 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10598 PyObject *resultobj;
10599 wxInputStream *arg1 = 0 ;
10600 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10601 int arg3 = (int) -1 ;
10602 wxImage *result;
10603 wxPyInputStream *temp1 ;
10604 bool created1 ;
10605 PyObject * obj0 = 0 ;
10606 PyObject * obj1 = 0 ;
10607 PyObject * obj2 = 0 ;
10608 char *kwnames[] = {
10609 (char *) "stream",(char *) "type",(char *) "index", NULL
10610 };
10611
10612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10613 {
10614 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10615 arg1 = temp1->m_wxis;
10616 created1 = false;
10617 } else {
10618 PyErr_Clear(); // clear the failure of the wxPyConvert above
10619 arg1 = wxPyCBInputStream_create(obj0, false);
10620 if (arg1 == NULL) {
10621 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10622 SWIG_fail;
10623 }
10624 created1 = true;
10625 }
10626 }
10627 if (obj1) {
10628 {
10629 arg2 = (long)(SWIG_As_long(obj1));
10630 if (SWIG_arg_fail(2)) SWIG_fail;
10631 }
10632 }
10633 if (obj2) {
10634 {
10635 arg3 = (int)(SWIG_As_int(obj2));
10636 if (SWIG_arg_fail(3)) SWIG_fail;
10637 }
10638 }
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10642
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10647 {
10648 if (created1) delete arg1;
10649 }
10650 return resultobj;
10651 fail:
10652 {
10653 if (created1) delete arg1;
10654 }
10655 return NULL;
10656 }
10657
10658
10659 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10660 PyObject *resultobj;
10661 wxInputStream *arg1 = 0 ;
10662 wxString *arg2 = 0 ;
10663 int arg3 = (int) -1 ;
10664 wxImage *result;
10665 wxPyInputStream *temp1 ;
10666 bool created1 ;
10667 bool temp2 = false ;
10668 PyObject * obj0 = 0 ;
10669 PyObject * obj1 = 0 ;
10670 PyObject * obj2 = 0 ;
10671 char *kwnames[] = {
10672 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10673 };
10674
10675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10676 {
10677 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10678 arg1 = temp1->m_wxis;
10679 created1 = false;
10680 } else {
10681 PyErr_Clear(); // clear the failure of the wxPyConvert above
10682 arg1 = wxPyCBInputStream_create(obj0, false);
10683 if (arg1 == NULL) {
10684 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10685 SWIG_fail;
10686 }
10687 created1 = true;
10688 }
10689 }
10690 {
10691 arg2 = wxString_in_helper(obj1);
10692 if (arg2 == NULL) SWIG_fail;
10693 temp2 = true;
10694 }
10695 if (obj2) {
10696 {
10697 arg3 = (int)(SWIG_As_int(obj2));
10698 if (SWIG_arg_fail(3)) SWIG_fail;
10699 }
10700 }
10701 {
10702 PyThreadState* __tstate = wxPyBeginAllowThreads();
10703 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10704
10705 wxPyEndAllowThreads(__tstate);
10706 if (PyErr_Occurred()) SWIG_fail;
10707 }
10708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10709 {
10710 if (created1) delete arg1;
10711 }
10712 {
10713 if (temp2)
10714 delete arg2;
10715 }
10716 return resultobj;
10717 fail:
10718 {
10719 if (created1) delete arg1;
10720 }
10721 {
10722 if (temp2)
10723 delete arg2;
10724 }
10725 return NULL;
10726 }
10727
10728
10729 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj;
10731 int arg1 = (int) 0 ;
10732 int arg2 = (int) 0 ;
10733 bool arg3 = (bool) true ;
10734 wxImage *result;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 PyObject * obj2 = 0 ;
10738 char *kwnames[] = {
10739 (char *) "width",(char *) "height",(char *) "clear", NULL
10740 };
10741
10742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10743 if (obj0) {
10744 {
10745 arg1 = (int)(SWIG_As_int(obj0));
10746 if (SWIG_arg_fail(1)) SWIG_fail;
10747 }
10748 }
10749 if (obj1) {
10750 {
10751 arg2 = (int)(SWIG_As_int(obj1));
10752 if (SWIG_arg_fail(2)) SWIG_fail;
10753 }
10754 }
10755 if (obj2) {
10756 {
10757 arg3 = (bool)(SWIG_As_bool(obj2));
10758 if (SWIG_arg_fail(3)) SWIG_fail;
10759 }
10760 }
10761 {
10762 PyThreadState* __tstate = wxPyBeginAllowThreads();
10763 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10764
10765 wxPyEndAllowThreads(__tstate);
10766 if (PyErr_Occurred()) SWIG_fail;
10767 }
10768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10769 return resultobj;
10770 fail:
10771 return NULL;
10772 }
10773
10774
10775 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10776 PyObject *resultobj;
10777 wxBitmap *arg1 = 0 ;
10778 wxImage *result;
10779 PyObject * obj0 = 0 ;
10780 char *kwnames[] = {
10781 (char *) "bitmap", NULL
10782 };
10783
10784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10785 {
10786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10787 if (SWIG_arg_fail(1)) SWIG_fail;
10788 if (arg1 == NULL) {
10789 SWIG_null_ref("wxBitmap");
10790 }
10791 if (SWIG_arg_fail(1)) SWIG_fail;
10792 }
10793 {
10794 if (!wxPyCheckForApp()) SWIG_fail;
10795 PyThreadState* __tstate = wxPyBeginAllowThreads();
10796 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10797
10798 wxPyEndAllowThreads(__tstate);
10799 if (PyErr_Occurred()) SWIG_fail;
10800 }
10801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10802 return resultobj;
10803 fail:
10804 return NULL;
10805 }
10806
10807
10808 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10809 PyObject *resultobj;
10810 int arg1 ;
10811 int arg2 ;
10812 unsigned char *arg3 = (unsigned char *) 0 ;
10813 wxImage *result;
10814 PyObject * obj0 = 0 ;
10815 PyObject * obj1 = 0 ;
10816 PyObject * obj2 = 0 ;
10817 char *kwnames[] = {
10818 (char *) "width",(char *) "height",(char *) "data", NULL
10819 };
10820
10821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10822 {
10823 arg1 = (int)(SWIG_As_int(obj0));
10824 if (SWIG_arg_fail(1)) SWIG_fail;
10825 }
10826 {
10827 arg2 = (int)(SWIG_As_int(obj1));
10828 if (SWIG_arg_fail(2)) SWIG_fail;
10829 }
10830 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10831 if (SWIG_arg_fail(3)) SWIG_fail;
10832 {
10833 PyThreadState* __tstate = wxPyBeginAllowThreads();
10834 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10835
10836 wxPyEndAllowThreads(__tstate);
10837 if (PyErr_Occurred()) SWIG_fail;
10838 }
10839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj;
10848 int arg1 ;
10849 int arg2 ;
10850 unsigned char *arg3 = (unsigned char *) 0 ;
10851 unsigned char *arg4 = (unsigned char *) 0 ;
10852 wxImage *result;
10853 PyObject * obj0 = 0 ;
10854 PyObject * obj1 = 0 ;
10855 PyObject * obj2 = 0 ;
10856 PyObject * obj3 = 0 ;
10857 char *kwnames[] = {
10858 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10859 };
10860
10861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10862 {
10863 arg1 = (int)(SWIG_As_int(obj0));
10864 if (SWIG_arg_fail(1)) SWIG_fail;
10865 }
10866 {
10867 arg2 = (int)(SWIG_As_int(obj1));
10868 if (SWIG_arg_fail(2)) SWIG_fail;
10869 }
10870 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10871 if (SWIG_arg_fail(3)) SWIG_fail;
10872 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10873 if (SWIG_arg_fail(4)) SWIG_fail;
10874 {
10875 PyThreadState* __tstate = wxPyBeginAllowThreads();
10876 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10877
10878 wxPyEndAllowThreads(__tstate);
10879 if (PyErr_Occurred()) SWIG_fail;
10880 }
10881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj;
10890 wxImage *arg1 = (wxImage *) 0 ;
10891 int arg2 ;
10892 int arg3 ;
10893 PyObject * obj0 = 0 ;
10894 PyObject * obj1 = 0 ;
10895 PyObject * obj2 = 0 ;
10896 char *kwnames[] = {
10897 (char *) "self",(char *) "width",(char *) "height", NULL
10898 };
10899
10900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10902 if (SWIG_arg_fail(1)) SWIG_fail;
10903 {
10904 arg2 = (int)(SWIG_As_int(obj1));
10905 if (SWIG_arg_fail(2)) SWIG_fail;
10906 }
10907 {
10908 arg3 = (int)(SWIG_As_int(obj2));
10909 if (SWIG_arg_fail(3)) SWIG_fail;
10910 }
10911 {
10912 PyThreadState* __tstate = wxPyBeginAllowThreads();
10913 (arg1)->Create(arg2,arg3);
10914
10915 wxPyEndAllowThreads(__tstate);
10916 if (PyErr_Occurred()) SWIG_fail;
10917 }
10918 Py_INCREF(Py_None); resultobj = Py_None;
10919 return resultobj;
10920 fail:
10921 return NULL;
10922 }
10923
10924
10925 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10926 PyObject *resultobj;
10927 wxImage *arg1 = (wxImage *) 0 ;
10928 PyObject * obj0 = 0 ;
10929 char *kwnames[] = {
10930 (char *) "self", NULL
10931 };
10932
10933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10935 if (SWIG_arg_fail(1)) SWIG_fail;
10936 {
10937 PyThreadState* __tstate = wxPyBeginAllowThreads();
10938 (arg1)->Destroy();
10939
10940 wxPyEndAllowThreads(__tstate);
10941 if (PyErr_Occurred()) SWIG_fail;
10942 }
10943 Py_INCREF(Py_None); resultobj = Py_None;
10944 return resultobj;
10945 fail:
10946 return NULL;
10947 }
10948
10949
10950 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10951 PyObject *resultobj;
10952 wxImage *arg1 = (wxImage *) 0 ;
10953 int arg2 ;
10954 int arg3 ;
10955 SwigValueWrapper<wxImage > result;
10956 PyObject * obj0 = 0 ;
10957 PyObject * obj1 = 0 ;
10958 PyObject * obj2 = 0 ;
10959 char *kwnames[] = {
10960 (char *) "self",(char *) "width",(char *) "height", NULL
10961 };
10962
10963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10965 if (SWIG_arg_fail(1)) SWIG_fail;
10966 {
10967 arg2 = (int)(SWIG_As_int(obj1));
10968 if (SWIG_arg_fail(2)) SWIG_fail;
10969 }
10970 {
10971 arg3 = (int)(SWIG_As_int(obj2));
10972 if (SWIG_arg_fail(3)) SWIG_fail;
10973 }
10974 {
10975 PyThreadState* __tstate = wxPyBeginAllowThreads();
10976 result = (arg1)->Scale(arg2,arg3);
10977
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 {
10982 wxImage * resultptr;
10983 resultptr = new wxImage((wxImage &)(result));
10984 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10985 }
10986 return resultobj;
10987 fail:
10988 return NULL;
10989 }
10990
10991
10992 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10993 PyObject *resultobj;
10994 wxImage *arg1 = (wxImage *) 0 ;
10995 int arg2 ;
10996 int arg3 ;
10997 SwigValueWrapper<wxImage > result;
10998 PyObject * obj0 = 0 ;
10999 PyObject * obj1 = 0 ;
11000 PyObject * obj2 = 0 ;
11001 char *kwnames[] = {
11002 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11003 };
11004
11005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11007 if (SWIG_arg_fail(1)) SWIG_fail;
11008 {
11009 arg2 = (int)(SWIG_As_int(obj1));
11010 if (SWIG_arg_fail(2)) SWIG_fail;
11011 }
11012 {
11013 arg3 = (int)(SWIG_As_int(obj2));
11014 if (SWIG_arg_fail(3)) SWIG_fail;
11015 }
11016 {
11017 PyThreadState* __tstate = wxPyBeginAllowThreads();
11018 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11019
11020 wxPyEndAllowThreads(__tstate);
11021 if (PyErr_Occurred()) SWIG_fail;
11022 }
11023 {
11024 wxImage * resultptr;
11025 resultptr = new wxImage((wxImage &)(result));
11026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11027 }
11028 return resultobj;
11029 fail:
11030 return NULL;
11031 }
11032
11033
11034 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11035 PyObject *resultobj;
11036 wxImage *arg1 = (wxImage *) 0 ;
11037 int arg2 ;
11038 int arg3 ;
11039 wxImage *result;
11040 PyObject * obj0 = 0 ;
11041 PyObject * obj1 = 0 ;
11042 PyObject * obj2 = 0 ;
11043 char *kwnames[] = {
11044 (char *) "self",(char *) "width",(char *) "height", NULL
11045 };
11046
11047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11049 if (SWIG_arg_fail(1)) SWIG_fail;
11050 {
11051 arg2 = (int)(SWIG_As_int(obj1));
11052 if (SWIG_arg_fail(2)) SWIG_fail;
11053 }
11054 {
11055 arg3 = (int)(SWIG_As_int(obj2));
11056 if (SWIG_arg_fail(3)) SWIG_fail;
11057 }
11058 {
11059 PyThreadState* __tstate = wxPyBeginAllowThreads();
11060 {
11061 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11062 result = (wxImage *) &_result_ref;
11063 }
11064
11065 wxPyEndAllowThreads(__tstate);
11066 if (PyErr_Occurred()) SWIG_fail;
11067 }
11068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11069 return resultobj;
11070 fail:
11071 return NULL;
11072 }
11073
11074
11075 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11076 PyObject *resultobj;
11077 wxImage *arg1 = (wxImage *) 0 ;
11078 wxSize *arg2 = 0 ;
11079 wxPoint *arg3 = 0 ;
11080 int arg4 = (int) -1 ;
11081 int arg5 = (int) -1 ;
11082 int arg6 = (int) -1 ;
11083 wxImage *result;
11084 wxSize temp2 ;
11085 wxPoint temp3 ;
11086 PyObject * obj0 = 0 ;
11087 PyObject * obj1 = 0 ;
11088 PyObject * obj2 = 0 ;
11089 PyObject * obj3 = 0 ;
11090 PyObject * obj4 = 0 ;
11091 PyObject * obj5 = 0 ;
11092 char *kwnames[] = {
11093 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11094 };
11095
11096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11098 if (SWIG_arg_fail(1)) SWIG_fail;
11099 {
11100 arg2 = &temp2;
11101 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11102 }
11103 {
11104 arg3 = &temp3;
11105 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11106 }
11107 if (obj3) {
11108 {
11109 arg4 = (int)(SWIG_As_int(obj3));
11110 if (SWIG_arg_fail(4)) SWIG_fail;
11111 }
11112 }
11113 if (obj4) {
11114 {
11115 arg5 = (int)(SWIG_As_int(obj4));
11116 if (SWIG_arg_fail(5)) SWIG_fail;
11117 }
11118 }
11119 if (obj5) {
11120 {
11121 arg6 = (int)(SWIG_As_int(obj5));
11122 if (SWIG_arg_fail(6)) SWIG_fail;
11123 }
11124 }
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 {
11128 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11129 result = (wxImage *) &_result_ref;
11130 }
11131
11132 wxPyEndAllowThreads(__tstate);
11133 if (PyErr_Occurred()) SWIG_fail;
11134 }
11135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11136 return resultobj;
11137 fail:
11138 return NULL;
11139 }
11140
11141
11142 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11143 PyObject *resultobj;
11144 wxImage *arg1 = (wxImage *) 0 ;
11145 int arg2 ;
11146 int arg3 ;
11147 unsigned char arg4 ;
11148 unsigned char arg5 ;
11149 unsigned char arg6 ;
11150 PyObject * obj0 = 0 ;
11151 PyObject * obj1 = 0 ;
11152 PyObject * obj2 = 0 ;
11153 PyObject * obj3 = 0 ;
11154 PyObject * obj4 = 0 ;
11155 PyObject * obj5 = 0 ;
11156 char *kwnames[] = {
11157 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11158 };
11159
11160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11162 if (SWIG_arg_fail(1)) SWIG_fail;
11163 {
11164 arg2 = (int)(SWIG_As_int(obj1));
11165 if (SWIG_arg_fail(2)) SWIG_fail;
11166 }
11167 {
11168 arg3 = (int)(SWIG_As_int(obj2));
11169 if (SWIG_arg_fail(3)) SWIG_fail;
11170 }
11171 {
11172 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11173 if (SWIG_arg_fail(4)) SWIG_fail;
11174 }
11175 {
11176 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11177 if (SWIG_arg_fail(5)) SWIG_fail;
11178 }
11179 {
11180 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11181 if (SWIG_arg_fail(6)) SWIG_fail;
11182 }
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11186
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 Py_INCREF(Py_None); resultobj = Py_None;
11191 return resultobj;
11192 fail:
11193 return NULL;
11194 }
11195
11196
11197 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11198 PyObject *resultobj;
11199 wxImage *arg1 = (wxImage *) 0 ;
11200 wxRect *arg2 = 0 ;
11201 unsigned char arg3 ;
11202 unsigned char arg4 ;
11203 unsigned char arg5 ;
11204 wxRect temp2 ;
11205 PyObject * obj0 = 0 ;
11206 PyObject * obj1 = 0 ;
11207 PyObject * obj2 = 0 ;
11208 PyObject * obj3 = 0 ;
11209 PyObject * obj4 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11216 if (SWIG_arg_fail(1)) SWIG_fail;
11217 {
11218 arg2 = &temp2;
11219 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11220 }
11221 {
11222 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11223 if (SWIG_arg_fail(3)) SWIG_fail;
11224 }
11225 {
11226 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11227 if (SWIG_arg_fail(4)) SWIG_fail;
11228 }
11229 {
11230 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11231 if (SWIG_arg_fail(5)) SWIG_fail;
11232 }
11233 {
11234 PyThreadState* __tstate = wxPyBeginAllowThreads();
11235 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11236
11237 wxPyEndAllowThreads(__tstate);
11238 if (PyErr_Occurred()) SWIG_fail;
11239 }
11240 Py_INCREF(Py_None); resultobj = Py_None;
11241 return resultobj;
11242 fail:
11243 return NULL;
11244 }
11245
11246
11247 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11248 PyObject *resultobj;
11249 wxImage *arg1 = (wxImage *) 0 ;
11250 int arg2 ;
11251 int arg3 ;
11252 unsigned char result;
11253 PyObject * obj0 = 0 ;
11254 PyObject * obj1 = 0 ;
11255 PyObject * obj2 = 0 ;
11256 char *kwnames[] = {
11257 (char *) "self",(char *) "x",(char *) "y", NULL
11258 };
11259
11260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11262 if (SWIG_arg_fail(1)) SWIG_fail;
11263 {
11264 arg2 = (int)(SWIG_As_int(obj1));
11265 if (SWIG_arg_fail(2)) SWIG_fail;
11266 }
11267 {
11268 arg3 = (int)(SWIG_As_int(obj2));
11269 if (SWIG_arg_fail(3)) SWIG_fail;
11270 }
11271 {
11272 PyThreadState* __tstate = wxPyBeginAllowThreads();
11273 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11274
11275 wxPyEndAllowThreads(__tstate);
11276 if (PyErr_Occurred()) SWIG_fail;
11277 }
11278 {
11279 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11280 }
11281 return resultobj;
11282 fail:
11283 return NULL;
11284 }
11285
11286
11287 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj;
11289 wxImage *arg1 = (wxImage *) 0 ;
11290 int arg2 ;
11291 int arg3 ;
11292 unsigned char result;
11293 PyObject * obj0 = 0 ;
11294 PyObject * obj1 = 0 ;
11295 PyObject * obj2 = 0 ;
11296 char *kwnames[] = {
11297 (char *) "self",(char *) "x",(char *) "y", NULL
11298 };
11299
11300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11302 if (SWIG_arg_fail(1)) SWIG_fail;
11303 {
11304 arg2 = (int)(SWIG_As_int(obj1));
11305 if (SWIG_arg_fail(2)) SWIG_fail;
11306 }
11307 {
11308 arg3 = (int)(SWIG_As_int(obj2));
11309 if (SWIG_arg_fail(3)) SWIG_fail;
11310 }
11311 {
11312 PyThreadState* __tstate = wxPyBeginAllowThreads();
11313 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11314
11315 wxPyEndAllowThreads(__tstate);
11316 if (PyErr_Occurred()) SWIG_fail;
11317 }
11318 {
11319 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11320 }
11321 return resultobj;
11322 fail:
11323 return NULL;
11324 }
11325
11326
11327 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj;
11329 wxImage *arg1 = (wxImage *) 0 ;
11330 int arg2 ;
11331 int arg3 ;
11332 unsigned char result;
11333 PyObject * obj0 = 0 ;
11334 PyObject * obj1 = 0 ;
11335 PyObject * obj2 = 0 ;
11336 char *kwnames[] = {
11337 (char *) "self",(char *) "x",(char *) "y", NULL
11338 };
11339
11340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11342 if (SWIG_arg_fail(1)) SWIG_fail;
11343 {
11344 arg2 = (int)(SWIG_As_int(obj1));
11345 if (SWIG_arg_fail(2)) SWIG_fail;
11346 }
11347 {
11348 arg3 = (int)(SWIG_As_int(obj2));
11349 if (SWIG_arg_fail(3)) SWIG_fail;
11350 }
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11354
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 {
11359 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11360 }
11361 return resultobj;
11362 fail:
11363 return NULL;
11364 }
11365
11366
11367 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11368 PyObject *resultobj;
11369 wxImage *arg1 = (wxImage *) 0 ;
11370 int arg2 ;
11371 int arg3 ;
11372 unsigned char arg4 ;
11373 PyObject * obj0 = 0 ;
11374 PyObject * obj1 = 0 ;
11375 PyObject * obj2 = 0 ;
11376 PyObject * obj3 = 0 ;
11377 char *kwnames[] = {
11378 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11379 };
11380
11381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11383 if (SWIG_arg_fail(1)) SWIG_fail;
11384 {
11385 arg2 = (int)(SWIG_As_int(obj1));
11386 if (SWIG_arg_fail(2)) SWIG_fail;
11387 }
11388 {
11389 arg3 = (int)(SWIG_As_int(obj2));
11390 if (SWIG_arg_fail(3)) SWIG_fail;
11391 }
11392 {
11393 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11394 if (SWIG_arg_fail(4)) SWIG_fail;
11395 }
11396 {
11397 PyThreadState* __tstate = wxPyBeginAllowThreads();
11398 (arg1)->SetAlpha(arg2,arg3,arg4);
11399
11400 wxPyEndAllowThreads(__tstate);
11401 if (PyErr_Occurred()) SWIG_fail;
11402 }
11403 Py_INCREF(Py_None); resultobj = Py_None;
11404 return resultobj;
11405 fail:
11406 return NULL;
11407 }
11408
11409
11410 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11411 PyObject *resultobj;
11412 wxImage *arg1 = (wxImage *) 0 ;
11413 int arg2 ;
11414 int arg3 ;
11415 unsigned char result;
11416 PyObject * obj0 = 0 ;
11417 PyObject * obj1 = 0 ;
11418 PyObject * obj2 = 0 ;
11419 char *kwnames[] = {
11420 (char *) "self",(char *) "x",(char *) "y", NULL
11421 };
11422
11423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11425 if (SWIG_arg_fail(1)) SWIG_fail;
11426 {
11427 arg2 = (int)(SWIG_As_int(obj1));
11428 if (SWIG_arg_fail(2)) SWIG_fail;
11429 }
11430 {
11431 arg3 = (int)(SWIG_As_int(obj2));
11432 if (SWIG_arg_fail(3)) SWIG_fail;
11433 }
11434 {
11435 PyThreadState* __tstate = wxPyBeginAllowThreads();
11436 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11437
11438 wxPyEndAllowThreads(__tstate);
11439 if (PyErr_Occurred()) SWIG_fail;
11440 }
11441 {
11442 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11443 }
11444 return resultobj;
11445 fail:
11446 return NULL;
11447 }
11448
11449
11450 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj;
11452 wxImage *arg1 = (wxImage *) 0 ;
11453 bool result;
11454 PyObject * obj0 = 0 ;
11455 char *kwnames[] = {
11456 (char *) "self", NULL
11457 };
11458
11459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11461 if (SWIG_arg_fail(1)) SWIG_fail;
11462 {
11463 PyThreadState* __tstate = wxPyBeginAllowThreads();
11464 result = (bool)(arg1)->HasAlpha();
11465
11466 wxPyEndAllowThreads(__tstate);
11467 if (PyErr_Occurred()) SWIG_fail;
11468 }
11469 {
11470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11471 }
11472 return resultobj;
11473 fail:
11474 return NULL;
11475 }
11476
11477
11478 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11479 PyObject *resultobj;
11480 wxImage *arg1 = (wxImage *) 0 ;
11481 PyObject * obj0 = 0 ;
11482 char *kwnames[] = {
11483 (char *) "self", NULL
11484 };
11485
11486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11488 if (SWIG_arg_fail(1)) SWIG_fail;
11489 {
11490 PyThreadState* __tstate = wxPyBeginAllowThreads();
11491 (arg1)->InitAlpha();
11492
11493 wxPyEndAllowThreads(__tstate);
11494 if (PyErr_Occurred()) SWIG_fail;
11495 }
11496 Py_INCREF(Py_None); resultobj = Py_None;
11497 return resultobj;
11498 fail:
11499 return NULL;
11500 }
11501
11502
11503 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11504 PyObject *resultobj;
11505 wxImage *arg1 = (wxImage *) 0 ;
11506 byte *arg2 = (byte *) 0 ;
11507 byte *arg3 = (byte *) 0 ;
11508 byte *arg4 = (byte *) 0 ;
11509 byte arg5 = (byte) 0 ;
11510 byte arg6 = (byte) 0 ;
11511 byte arg7 = (byte) 0 ;
11512 bool result;
11513 byte temp2 ;
11514 int res2 = 0 ;
11515 byte temp3 ;
11516 int res3 = 0 ;
11517 byte temp4 ;
11518 int res4 = 0 ;
11519 PyObject * obj0 = 0 ;
11520 PyObject * obj1 = 0 ;
11521 PyObject * obj2 = 0 ;
11522 PyObject * obj3 = 0 ;
11523 char *kwnames[] = {
11524 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11525 };
11526
11527 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11528 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11529 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11532 if (SWIG_arg_fail(1)) SWIG_fail;
11533 if (obj1) {
11534 {
11535 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11536 if (SWIG_arg_fail(5)) SWIG_fail;
11537 }
11538 }
11539 if (obj2) {
11540 {
11541 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11542 if (SWIG_arg_fail(6)) SWIG_fail;
11543 }
11544 }
11545 if (obj3) {
11546 {
11547 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11548 if (SWIG_arg_fail(7)) SWIG_fail;
11549 }
11550 }
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11554
11555 wxPyEndAllowThreads(__tstate);
11556 if (PyErr_Occurred()) SWIG_fail;
11557 }
11558 {
11559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11560 }
11561 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11562 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11563 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11564 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11565 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11566 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11567 return resultobj;
11568 fail:
11569 return NULL;
11570 }
11571
11572
11573 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11574 PyObject *resultobj;
11575 wxImage *arg1 = (wxImage *) 0 ;
11576 byte arg2 = (byte) 128 ;
11577 bool result;
11578 PyObject * obj0 = 0 ;
11579 PyObject * obj1 = 0 ;
11580 char *kwnames[] = {
11581 (char *) "self",(char *) "threshold", NULL
11582 };
11583
11584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11586 if (SWIG_arg_fail(1)) SWIG_fail;
11587 if (obj1) {
11588 {
11589 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11590 if (SWIG_arg_fail(2)) SWIG_fail;
11591 }
11592 }
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11596
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 {
11601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11602 }
11603 return resultobj;
11604 fail:
11605 return NULL;
11606 }
11607
11608
11609 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11610 PyObject *resultobj;
11611 wxImage *arg1 = (wxImage *) 0 ;
11612 unsigned char arg2 ;
11613 unsigned char arg3 ;
11614 unsigned char arg4 ;
11615 bool result;
11616 PyObject * obj0 = 0 ;
11617 PyObject * obj1 = 0 ;
11618 PyObject * obj2 = 0 ;
11619 PyObject * obj3 = 0 ;
11620 char *kwnames[] = {
11621 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11622 };
11623
11624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11626 if (SWIG_arg_fail(1)) SWIG_fail;
11627 {
11628 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11629 if (SWIG_arg_fail(2)) SWIG_fail;
11630 }
11631 {
11632 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11633 if (SWIG_arg_fail(3)) SWIG_fail;
11634 }
11635 {
11636 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11637 if (SWIG_arg_fail(4)) SWIG_fail;
11638 }
11639 {
11640 PyThreadState* __tstate = wxPyBeginAllowThreads();
11641 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11642
11643 wxPyEndAllowThreads(__tstate);
11644 if (PyErr_Occurred()) SWIG_fail;
11645 }
11646 {
11647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11648 }
11649 return resultobj;
11650 fail:
11651 return NULL;
11652 }
11653
11654
11655 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11656 PyObject *resultobj;
11657 wxImage *arg1 = (wxImage *) 0 ;
11658 wxImage *arg2 = 0 ;
11659 byte arg3 ;
11660 byte arg4 ;
11661 byte arg5 ;
11662 bool result;
11663 PyObject * obj0 = 0 ;
11664 PyObject * obj1 = 0 ;
11665 PyObject * obj2 = 0 ;
11666 PyObject * obj3 = 0 ;
11667 PyObject * obj4 = 0 ;
11668 char *kwnames[] = {
11669 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11670 };
11671
11672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11674 if (SWIG_arg_fail(1)) SWIG_fail;
11675 {
11676 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11677 if (SWIG_arg_fail(2)) SWIG_fail;
11678 if (arg2 == NULL) {
11679 SWIG_null_ref("wxImage");
11680 }
11681 if (SWIG_arg_fail(2)) SWIG_fail;
11682 }
11683 {
11684 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11685 if (SWIG_arg_fail(3)) SWIG_fail;
11686 }
11687 {
11688 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11689 if (SWIG_arg_fail(4)) SWIG_fail;
11690 }
11691 {
11692 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11693 if (SWIG_arg_fail(5)) SWIG_fail;
11694 }
11695 {
11696 PyThreadState* __tstate = wxPyBeginAllowThreads();
11697 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11698
11699 wxPyEndAllowThreads(__tstate);
11700 if (PyErr_Occurred()) SWIG_fail;
11701 }
11702 {
11703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11704 }
11705 return resultobj;
11706 fail:
11707 return NULL;
11708 }
11709
11710
11711 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11712 PyObject *resultobj;
11713 wxString *arg1 = 0 ;
11714 bool result;
11715 bool temp1 = false ;
11716 PyObject * obj0 = 0 ;
11717 char *kwnames[] = {
11718 (char *) "name", NULL
11719 };
11720
11721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11722 {
11723 arg1 = wxString_in_helper(obj0);
11724 if (arg1 == NULL) SWIG_fail;
11725 temp1 = true;
11726 }
11727 {
11728 PyThreadState* __tstate = wxPyBeginAllowThreads();
11729 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11730
11731 wxPyEndAllowThreads(__tstate);
11732 if (PyErr_Occurred()) SWIG_fail;
11733 }
11734 {
11735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11736 }
11737 {
11738 if (temp1)
11739 delete arg1;
11740 }
11741 return resultobj;
11742 fail:
11743 {
11744 if (temp1)
11745 delete arg1;
11746 }
11747 return NULL;
11748 }
11749
11750
11751 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11752 PyObject *resultobj;
11753 wxString *arg1 = 0 ;
11754 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11755 int result;
11756 bool temp1 = false ;
11757 PyObject * obj0 = 0 ;
11758 PyObject * obj1 = 0 ;
11759 char *kwnames[] = {
11760 (char *) "name",(char *) "type", NULL
11761 };
11762
11763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11764 {
11765 arg1 = wxString_in_helper(obj0);
11766 if (arg1 == NULL) SWIG_fail;
11767 temp1 = true;
11768 }
11769 if (obj1) {
11770 {
11771 arg2 = (long)(SWIG_As_long(obj1));
11772 if (SWIG_arg_fail(2)) SWIG_fail;
11773 }
11774 }
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11778
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 {
11783 resultobj = SWIG_From_int((int)(result));
11784 }
11785 {
11786 if (temp1)
11787 delete arg1;
11788 }
11789 return resultobj;
11790 fail:
11791 {
11792 if (temp1)
11793 delete arg1;
11794 }
11795 return NULL;
11796 }
11797
11798
11799 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11800 PyObject *resultobj;
11801 wxImage *arg1 = (wxImage *) 0 ;
11802 wxString *arg2 = 0 ;
11803 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11804 int arg4 = (int) -1 ;
11805 bool result;
11806 bool temp2 = false ;
11807 PyObject * obj0 = 0 ;
11808 PyObject * obj1 = 0 ;
11809 PyObject * obj2 = 0 ;
11810 PyObject * obj3 = 0 ;
11811 char *kwnames[] = {
11812 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11813 };
11814
11815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11817 if (SWIG_arg_fail(1)) SWIG_fail;
11818 {
11819 arg2 = wxString_in_helper(obj1);
11820 if (arg2 == NULL) SWIG_fail;
11821 temp2 = true;
11822 }
11823 if (obj2) {
11824 {
11825 arg3 = (long)(SWIG_As_long(obj2));
11826 if (SWIG_arg_fail(3)) SWIG_fail;
11827 }
11828 }
11829 if (obj3) {
11830 {
11831 arg4 = (int)(SWIG_As_int(obj3));
11832 if (SWIG_arg_fail(4)) SWIG_fail;
11833 }
11834 }
11835 {
11836 PyThreadState* __tstate = wxPyBeginAllowThreads();
11837 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11838
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 {
11843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11844 }
11845 {
11846 if (temp2)
11847 delete arg2;
11848 }
11849 return resultobj;
11850 fail:
11851 {
11852 if (temp2)
11853 delete arg2;
11854 }
11855 return NULL;
11856 }
11857
11858
11859 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj;
11861 wxImage *arg1 = (wxImage *) 0 ;
11862 wxString *arg2 = 0 ;
11863 wxString *arg3 = 0 ;
11864 int arg4 = (int) -1 ;
11865 bool result;
11866 bool temp2 = false ;
11867 bool temp3 = false ;
11868 PyObject * obj0 = 0 ;
11869 PyObject * obj1 = 0 ;
11870 PyObject * obj2 = 0 ;
11871 PyObject * obj3 = 0 ;
11872 char *kwnames[] = {
11873 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11874 };
11875
11876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11878 if (SWIG_arg_fail(1)) SWIG_fail;
11879 {
11880 arg2 = wxString_in_helper(obj1);
11881 if (arg2 == NULL) SWIG_fail;
11882 temp2 = true;
11883 }
11884 {
11885 arg3 = wxString_in_helper(obj2);
11886 if (arg3 == NULL) SWIG_fail;
11887 temp3 = true;
11888 }
11889 if (obj3) {
11890 {
11891 arg4 = (int)(SWIG_As_int(obj3));
11892 if (SWIG_arg_fail(4)) SWIG_fail;
11893 }
11894 }
11895 {
11896 PyThreadState* __tstate = wxPyBeginAllowThreads();
11897 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11898
11899 wxPyEndAllowThreads(__tstate);
11900 if (PyErr_Occurred()) SWIG_fail;
11901 }
11902 {
11903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11904 }
11905 {
11906 if (temp2)
11907 delete arg2;
11908 }
11909 {
11910 if (temp3)
11911 delete arg3;
11912 }
11913 return resultobj;
11914 fail:
11915 {
11916 if (temp2)
11917 delete arg2;
11918 }
11919 {
11920 if (temp3)
11921 delete arg3;
11922 }
11923 return NULL;
11924 }
11925
11926
11927 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11928 PyObject *resultobj;
11929 wxImage *arg1 = (wxImage *) 0 ;
11930 wxString *arg2 = 0 ;
11931 int arg3 ;
11932 bool result;
11933 bool temp2 = false ;
11934 PyObject * obj0 = 0 ;
11935 PyObject * obj1 = 0 ;
11936 PyObject * obj2 = 0 ;
11937 char *kwnames[] = {
11938 (char *) "self",(char *) "name",(char *) "type", NULL
11939 };
11940
11941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11943 if (SWIG_arg_fail(1)) SWIG_fail;
11944 {
11945 arg2 = wxString_in_helper(obj1);
11946 if (arg2 == NULL) SWIG_fail;
11947 temp2 = true;
11948 }
11949 {
11950 arg3 = (int)(SWIG_As_int(obj2));
11951 if (SWIG_arg_fail(3)) SWIG_fail;
11952 }
11953 {
11954 PyThreadState* __tstate = wxPyBeginAllowThreads();
11955 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11956
11957 wxPyEndAllowThreads(__tstate);
11958 if (PyErr_Occurred()) SWIG_fail;
11959 }
11960 {
11961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11962 }
11963 {
11964 if (temp2)
11965 delete arg2;
11966 }
11967 return resultobj;
11968 fail:
11969 {
11970 if (temp2)
11971 delete arg2;
11972 }
11973 return NULL;
11974 }
11975
11976
11977 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11978 PyObject *resultobj;
11979 wxImage *arg1 = (wxImage *) 0 ;
11980 wxString *arg2 = 0 ;
11981 wxString *arg3 = 0 ;
11982 bool result;
11983 bool temp2 = false ;
11984 bool temp3 = false ;
11985 PyObject * obj0 = 0 ;
11986 PyObject * obj1 = 0 ;
11987 PyObject * obj2 = 0 ;
11988 char *kwnames[] = {
11989 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11990 };
11991
11992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11994 if (SWIG_arg_fail(1)) SWIG_fail;
11995 {
11996 arg2 = wxString_in_helper(obj1);
11997 if (arg2 == NULL) SWIG_fail;
11998 temp2 = true;
11999 }
12000 {
12001 arg3 = wxString_in_helper(obj2);
12002 if (arg3 == NULL) SWIG_fail;
12003 temp3 = true;
12004 }
12005 {
12006 PyThreadState* __tstate = wxPyBeginAllowThreads();
12007 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12008
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 {
12013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12014 }
12015 {
12016 if (temp2)
12017 delete arg2;
12018 }
12019 {
12020 if (temp3)
12021 delete arg3;
12022 }
12023 return resultobj;
12024 fail:
12025 {
12026 if (temp2)
12027 delete arg2;
12028 }
12029 {
12030 if (temp3)
12031 delete arg3;
12032 }
12033 return NULL;
12034 }
12035
12036
12037 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12038 PyObject *resultobj;
12039 wxInputStream *arg1 = 0 ;
12040 bool result;
12041 wxPyInputStream *temp1 ;
12042 bool created1 ;
12043 PyObject * obj0 = 0 ;
12044 char *kwnames[] = {
12045 (char *) "stream", NULL
12046 };
12047
12048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12049 {
12050 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12051 arg1 = temp1->m_wxis;
12052 created1 = false;
12053 } else {
12054 PyErr_Clear(); // clear the failure of the wxPyConvert above
12055 arg1 = wxPyCBInputStream_create(obj0, false);
12056 if (arg1 == NULL) {
12057 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12058 SWIG_fail;
12059 }
12060 created1 = true;
12061 }
12062 }
12063 {
12064 PyThreadState* __tstate = wxPyBeginAllowThreads();
12065 result = (bool)wxImage::CanRead(*arg1);
12066
12067 wxPyEndAllowThreads(__tstate);
12068 if (PyErr_Occurred()) SWIG_fail;
12069 }
12070 {
12071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12072 }
12073 {
12074 if (created1) delete arg1;
12075 }
12076 return resultobj;
12077 fail:
12078 {
12079 if (created1) delete arg1;
12080 }
12081 return NULL;
12082 }
12083
12084
12085 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12086 PyObject *resultobj;
12087 wxImage *arg1 = (wxImage *) 0 ;
12088 wxInputStream *arg2 = 0 ;
12089 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12090 int arg4 = (int) -1 ;
12091 bool result;
12092 wxPyInputStream *temp2 ;
12093 bool created2 ;
12094 PyObject * obj0 = 0 ;
12095 PyObject * obj1 = 0 ;
12096 PyObject * obj2 = 0 ;
12097 PyObject * obj3 = 0 ;
12098 char *kwnames[] = {
12099 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12100 };
12101
12102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12104 if (SWIG_arg_fail(1)) SWIG_fail;
12105 {
12106 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12107 arg2 = temp2->m_wxis;
12108 created2 = false;
12109 } else {
12110 PyErr_Clear(); // clear the failure of the wxPyConvert above
12111 arg2 = wxPyCBInputStream_create(obj1, false);
12112 if (arg2 == NULL) {
12113 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12114 SWIG_fail;
12115 }
12116 created2 = true;
12117 }
12118 }
12119 if (obj2) {
12120 {
12121 arg3 = (long)(SWIG_As_long(obj2));
12122 if (SWIG_arg_fail(3)) SWIG_fail;
12123 }
12124 }
12125 if (obj3) {
12126 {
12127 arg4 = (int)(SWIG_As_int(obj3));
12128 if (SWIG_arg_fail(4)) SWIG_fail;
12129 }
12130 }
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12134
12135 wxPyEndAllowThreads(__tstate);
12136 if (PyErr_Occurred()) SWIG_fail;
12137 }
12138 {
12139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12140 }
12141 {
12142 if (created2) delete arg2;
12143 }
12144 return resultobj;
12145 fail:
12146 {
12147 if (created2) delete arg2;
12148 }
12149 return NULL;
12150 }
12151
12152
12153 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12154 PyObject *resultobj;
12155 wxImage *arg1 = (wxImage *) 0 ;
12156 wxInputStream *arg2 = 0 ;
12157 wxString *arg3 = 0 ;
12158 int arg4 = (int) -1 ;
12159 bool result;
12160 wxPyInputStream *temp2 ;
12161 bool created2 ;
12162 bool temp3 = false ;
12163 PyObject * obj0 = 0 ;
12164 PyObject * obj1 = 0 ;
12165 PyObject * obj2 = 0 ;
12166 PyObject * obj3 = 0 ;
12167 char *kwnames[] = {
12168 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12169 };
12170
12171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12173 if (SWIG_arg_fail(1)) SWIG_fail;
12174 {
12175 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12176 arg2 = temp2->m_wxis;
12177 created2 = false;
12178 } else {
12179 PyErr_Clear(); // clear the failure of the wxPyConvert above
12180 arg2 = wxPyCBInputStream_create(obj1, false);
12181 if (arg2 == NULL) {
12182 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12183 SWIG_fail;
12184 }
12185 created2 = true;
12186 }
12187 }
12188 {
12189 arg3 = wxString_in_helper(obj2);
12190 if (arg3 == NULL) SWIG_fail;
12191 temp3 = true;
12192 }
12193 if (obj3) {
12194 {
12195 arg4 = (int)(SWIG_As_int(obj3));
12196 if (SWIG_arg_fail(4)) SWIG_fail;
12197 }
12198 }
12199 {
12200 PyThreadState* __tstate = wxPyBeginAllowThreads();
12201 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12202
12203 wxPyEndAllowThreads(__tstate);
12204 if (PyErr_Occurred()) SWIG_fail;
12205 }
12206 {
12207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12208 }
12209 {
12210 if (created2) delete arg2;
12211 }
12212 {
12213 if (temp3)
12214 delete arg3;
12215 }
12216 return resultobj;
12217 fail:
12218 {
12219 if (created2) delete arg2;
12220 }
12221 {
12222 if (temp3)
12223 delete arg3;
12224 }
12225 return NULL;
12226 }
12227
12228
12229 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj;
12231 wxImage *arg1 = (wxImage *) 0 ;
12232 bool result;
12233 PyObject * obj0 = 0 ;
12234 char *kwnames[] = {
12235 (char *) "self", NULL
12236 };
12237
12238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12240 if (SWIG_arg_fail(1)) SWIG_fail;
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 result = (bool)(arg1)->Ok();
12244
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 {
12249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12250 }
12251 return resultobj;
12252 fail:
12253 return NULL;
12254 }
12255
12256
12257 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12258 PyObject *resultobj;
12259 wxImage *arg1 = (wxImage *) 0 ;
12260 int result;
12261 PyObject * obj0 = 0 ;
12262 char *kwnames[] = {
12263 (char *) "self", NULL
12264 };
12265
12266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12268 if (SWIG_arg_fail(1)) SWIG_fail;
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 result = (int)(arg1)->GetWidth();
12272
12273 wxPyEndAllowThreads(__tstate);
12274 if (PyErr_Occurred()) SWIG_fail;
12275 }
12276 {
12277 resultobj = SWIG_From_int((int)(result));
12278 }
12279 return resultobj;
12280 fail:
12281 return NULL;
12282 }
12283
12284
12285 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12286 PyObject *resultobj;
12287 wxImage *arg1 = (wxImage *) 0 ;
12288 int result;
12289 PyObject * obj0 = 0 ;
12290 char *kwnames[] = {
12291 (char *) "self", NULL
12292 };
12293
12294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12296 if (SWIG_arg_fail(1)) SWIG_fail;
12297 {
12298 PyThreadState* __tstate = wxPyBeginAllowThreads();
12299 result = (int)(arg1)->GetHeight();
12300
12301 wxPyEndAllowThreads(__tstate);
12302 if (PyErr_Occurred()) SWIG_fail;
12303 }
12304 {
12305 resultobj = SWIG_From_int((int)(result));
12306 }
12307 return resultobj;
12308 fail:
12309 return NULL;
12310 }
12311
12312
12313 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12314 PyObject *resultobj;
12315 wxImage *arg1 = (wxImage *) 0 ;
12316 wxSize result;
12317 PyObject * obj0 = 0 ;
12318 char *kwnames[] = {
12319 (char *) "self", NULL
12320 };
12321
12322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12324 if (SWIG_arg_fail(1)) SWIG_fail;
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 result = wxImage_GetSize(arg1);
12328
12329 wxPyEndAllowThreads(__tstate);
12330 if (PyErr_Occurred()) SWIG_fail;
12331 }
12332 {
12333 wxSize * resultptr;
12334 resultptr = new wxSize((wxSize &)(result));
12335 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12336 }
12337 return resultobj;
12338 fail:
12339 return NULL;
12340 }
12341
12342
12343 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12344 PyObject *resultobj;
12345 wxImage *arg1 = (wxImage *) 0 ;
12346 wxRect *arg2 = 0 ;
12347 SwigValueWrapper<wxImage > result;
12348 wxRect temp2 ;
12349 PyObject * obj0 = 0 ;
12350 PyObject * obj1 = 0 ;
12351 char *kwnames[] = {
12352 (char *) "self",(char *) "rect", NULL
12353 };
12354
12355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12357 if (SWIG_arg_fail(1)) SWIG_fail;
12358 {
12359 arg2 = &temp2;
12360 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12361 }
12362 {
12363 PyThreadState* __tstate = wxPyBeginAllowThreads();
12364 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12365
12366 wxPyEndAllowThreads(__tstate);
12367 if (PyErr_Occurred()) SWIG_fail;
12368 }
12369 {
12370 wxImage * resultptr;
12371 resultptr = new wxImage((wxImage &)(result));
12372 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12373 }
12374 return resultobj;
12375 fail:
12376 return NULL;
12377 }
12378
12379
12380 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12381 PyObject *resultobj;
12382 wxImage *arg1 = (wxImage *) 0 ;
12383 wxSize *arg2 = 0 ;
12384 wxPoint *arg3 = 0 ;
12385 int arg4 = (int) -1 ;
12386 int arg5 = (int) -1 ;
12387 int arg6 = (int) -1 ;
12388 SwigValueWrapper<wxImage > result;
12389 wxSize temp2 ;
12390 wxPoint temp3 ;
12391 PyObject * obj0 = 0 ;
12392 PyObject * obj1 = 0 ;
12393 PyObject * obj2 = 0 ;
12394 PyObject * obj3 = 0 ;
12395 PyObject * obj4 = 0 ;
12396 PyObject * obj5 = 0 ;
12397 char *kwnames[] = {
12398 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12399 };
12400
12401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12403 if (SWIG_arg_fail(1)) SWIG_fail;
12404 {
12405 arg2 = &temp2;
12406 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12407 }
12408 {
12409 arg3 = &temp3;
12410 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12411 }
12412 if (obj3) {
12413 {
12414 arg4 = (int)(SWIG_As_int(obj3));
12415 if (SWIG_arg_fail(4)) SWIG_fail;
12416 }
12417 }
12418 if (obj4) {
12419 {
12420 arg5 = (int)(SWIG_As_int(obj4));
12421 if (SWIG_arg_fail(5)) SWIG_fail;
12422 }
12423 }
12424 if (obj5) {
12425 {
12426 arg6 = (int)(SWIG_As_int(obj5));
12427 if (SWIG_arg_fail(6)) SWIG_fail;
12428 }
12429 }
12430 {
12431 PyThreadState* __tstate = wxPyBeginAllowThreads();
12432 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12433
12434 wxPyEndAllowThreads(__tstate);
12435 if (PyErr_Occurred()) SWIG_fail;
12436 }
12437 {
12438 wxImage * resultptr;
12439 resultptr = new wxImage((wxImage &)(result));
12440 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12441 }
12442 return resultobj;
12443 fail:
12444 return NULL;
12445 }
12446
12447
12448 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12449 PyObject *resultobj;
12450 wxImage *arg1 = (wxImage *) 0 ;
12451 SwigValueWrapper<wxImage > result;
12452 PyObject * obj0 = 0 ;
12453 char *kwnames[] = {
12454 (char *) "self", NULL
12455 };
12456
12457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12459 if (SWIG_arg_fail(1)) SWIG_fail;
12460 {
12461 PyThreadState* __tstate = wxPyBeginAllowThreads();
12462 result = (arg1)->Copy();
12463
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 {
12468 wxImage * resultptr;
12469 resultptr = new wxImage((wxImage &)(result));
12470 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12471 }
12472 return resultobj;
12473 fail:
12474 return NULL;
12475 }
12476
12477
12478 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12479 PyObject *resultobj;
12480 wxImage *arg1 = (wxImage *) 0 ;
12481 wxImage *arg2 = 0 ;
12482 int arg3 ;
12483 int arg4 ;
12484 PyObject * obj0 = 0 ;
12485 PyObject * obj1 = 0 ;
12486 PyObject * obj2 = 0 ;
12487 PyObject * obj3 = 0 ;
12488 char *kwnames[] = {
12489 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12490 };
12491
12492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12494 if (SWIG_arg_fail(1)) SWIG_fail;
12495 {
12496 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12497 if (SWIG_arg_fail(2)) SWIG_fail;
12498 if (arg2 == NULL) {
12499 SWIG_null_ref("wxImage");
12500 }
12501 if (SWIG_arg_fail(2)) SWIG_fail;
12502 }
12503 {
12504 arg3 = (int)(SWIG_As_int(obj2));
12505 if (SWIG_arg_fail(3)) SWIG_fail;
12506 }
12507 {
12508 arg4 = (int)(SWIG_As_int(obj3));
12509 if (SWIG_arg_fail(4)) SWIG_fail;
12510 }
12511 {
12512 PyThreadState* __tstate = wxPyBeginAllowThreads();
12513 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12514
12515 wxPyEndAllowThreads(__tstate);
12516 if (PyErr_Occurred()) SWIG_fail;
12517 }
12518 Py_INCREF(Py_None); resultobj = Py_None;
12519 return resultobj;
12520 fail:
12521 return NULL;
12522 }
12523
12524
12525 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12526 PyObject *resultobj;
12527 wxImage *arg1 = (wxImage *) 0 ;
12528 PyObject *result;
12529 PyObject * obj0 = 0 ;
12530 char *kwnames[] = {
12531 (char *) "self", NULL
12532 };
12533
12534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12536 if (SWIG_arg_fail(1)) SWIG_fail;
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 result = (PyObject *)wxImage_GetData(arg1);
12540
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 resultobj = result;
12545 return resultobj;
12546 fail:
12547 return NULL;
12548 }
12549
12550
12551 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12552 PyObject *resultobj;
12553 wxImage *arg1 = (wxImage *) 0 ;
12554 PyObject *arg2 = (PyObject *) 0 ;
12555 PyObject * obj0 = 0 ;
12556 PyObject * obj1 = 0 ;
12557 char *kwnames[] = {
12558 (char *) "self",(char *) "data", NULL
12559 };
12560
12561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12563 if (SWIG_arg_fail(1)) SWIG_fail;
12564 arg2 = obj1;
12565 {
12566 PyThreadState* __tstate = wxPyBeginAllowThreads();
12567 wxImage_SetData(arg1,arg2);
12568
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 Py_INCREF(Py_None); resultobj = Py_None;
12573 return resultobj;
12574 fail:
12575 return NULL;
12576 }
12577
12578
12579 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12580 PyObject *resultobj;
12581 wxImage *arg1 = (wxImage *) 0 ;
12582 PyObject *result;
12583 PyObject * obj0 = 0 ;
12584 char *kwnames[] = {
12585 (char *) "self", NULL
12586 };
12587
12588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12590 if (SWIG_arg_fail(1)) SWIG_fail;
12591 {
12592 PyThreadState* __tstate = wxPyBeginAllowThreads();
12593 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12594
12595 wxPyEndAllowThreads(__tstate);
12596 if (PyErr_Occurred()) SWIG_fail;
12597 }
12598 resultobj = result;
12599 return resultobj;
12600 fail:
12601 return NULL;
12602 }
12603
12604
12605 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12606 PyObject *resultobj;
12607 wxImage *arg1 = (wxImage *) 0 ;
12608 PyObject *arg2 = (PyObject *) 0 ;
12609 PyObject * obj0 = 0 ;
12610 PyObject * obj1 = 0 ;
12611 char *kwnames[] = {
12612 (char *) "self",(char *) "data", NULL
12613 };
12614
12615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12617 if (SWIG_arg_fail(1)) SWIG_fail;
12618 arg2 = obj1;
12619 {
12620 PyThreadState* __tstate = wxPyBeginAllowThreads();
12621 wxImage_SetDataBuffer(arg1,arg2);
12622
12623 wxPyEndAllowThreads(__tstate);
12624 if (PyErr_Occurred()) SWIG_fail;
12625 }
12626 Py_INCREF(Py_None); resultobj = Py_None;
12627 return resultobj;
12628 fail:
12629 return NULL;
12630 }
12631
12632
12633 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12634 PyObject *resultobj;
12635 wxImage *arg1 = (wxImage *) 0 ;
12636 PyObject *result;
12637 PyObject * obj0 = 0 ;
12638 char *kwnames[] = {
12639 (char *) "self", NULL
12640 };
12641
12642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12644 if (SWIG_arg_fail(1)) SWIG_fail;
12645 {
12646 PyThreadState* __tstate = wxPyBeginAllowThreads();
12647 result = (PyObject *)wxImage_GetAlphaData(arg1);
12648
12649 wxPyEndAllowThreads(__tstate);
12650 if (PyErr_Occurred()) SWIG_fail;
12651 }
12652 resultobj = result;
12653 return resultobj;
12654 fail:
12655 return NULL;
12656 }
12657
12658
12659 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12660 PyObject *resultobj;
12661 wxImage *arg1 = (wxImage *) 0 ;
12662 PyObject *arg2 = (PyObject *) 0 ;
12663 PyObject * obj0 = 0 ;
12664 PyObject * obj1 = 0 ;
12665 char *kwnames[] = {
12666 (char *) "self",(char *) "data", NULL
12667 };
12668
12669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12671 if (SWIG_arg_fail(1)) SWIG_fail;
12672 arg2 = obj1;
12673 {
12674 PyThreadState* __tstate = wxPyBeginAllowThreads();
12675 wxImage_SetAlphaData(arg1,arg2);
12676
12677 wxPyEndAllowThreads(__tstate);
12678 if (PyErr_Occurred()) SWIG_fail;
12679 }
12680 Py_INCREF(Py_None); resultobj = Py_None;
12681 return resultobj;
12682 fail:
12683 return NULL;
12684 }
12685
12686
12687 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12688 PyObject *resultobj;
12689 wxImage *arg1 = (wxImage *) 0 ;
12690 PyObject *result;
12691 PyObject * obj0 = 0 ;
12692 char *kwnames[] = {
12693 (char *) "self", NULL
12694 };
12695
12696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12698 if (SWIG_arg_fail(1)) SWIG_fail;
12699 {
12700 PyThreadState* __tstate = wxPyBeginAllowThreads();
12701 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12702
12703 wxPyEndAllowThreads(__tstate);
12704 if (PyErr_Occurred()) SWIG_fail;
12705 }
12706 resultobj = result;
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12714 PyObject *resultobj;
12715 wxImage *arg1 = (wxImage *) 0 ;
12716 PyObject *arg2 = (PyObject *) 0 ;
12717 PyObject * obj0 = 0 ;
12718 PyObject * obj1 = 0 ;
12719 char *kwnames[] = {
12720 (char *) "self",(char *) "data", NULL
12721 };
12722
12723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12725 if (SWIG_arg_fail(1)) SWIG_fail;
12726 arg2 = obj1;
12727 {
12728 PyThreadState* __tstate = wxPyBeginAllowThreads();
12729 wxImage_SetAlphaBuffer(arg1,arg2);
12730
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 Py_INCREF(Py_None); resultobj = Py_None;
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj;
12743 wxImage *arg1 = (wxImage *) 0 ;
12744 unsigned char arg2 ;
12745 unsigned char arg3 ;
12746 unsigned char arg4 ;
12747 PyObject * obj0 = 0 ;
12748 PyObject * obj1 = 0 ;
12749 PyObject * obj2 = 0 ;
12750 PyObject * obj3 = 0 ;
12751 char *kwnames[] = {
12752 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12753 };
12754
12755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12757 if (SWIG_arg_fail(1)) SWIG_fail;
12758 {
12759 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12760 if (SWIG_arg_fail(2)) SWIG_fail;
12761 }
12762 {
12763 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12764 if (SWIG_arg_fail(3)) SWIG_fail;
12765 }
12766 {
12767 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12768 if (SWIG_arg_fail(4)) SWIG_fail;
12769 }
12770 {
12771 PyThreadState* __tstate = wxPyBeginAllowThreads();
12772 (arg1)->SetMaskColour(arg2,arg3,arg4);
12773
12774 wxPyEndAllowThreads(__tstate);
12775 if (PyErr_Occurred()) SWIG_fail;
12776 }
12777 Py_INCREF(Py_None); resultobj = Py_None;
12778 return resultobj;
12779 fail:
12780 return NULL;
12781 }
12782
12783
12784 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12785 PyObject *resultobj;
12786 wxImage *arg1 = (wxImage *) 0 ;
12787 unsigned char *arg2 = (unsigned char *) 0 ;
12788 unsigned char *arg3 = (unsigned char *) 0 ;
12789 unsigned char *arg4 = (unsigned char *) 0 ;
12790 unsigned char temp2 ;
12791 int res2 = 0 ;
12792 unsigned char temp3 ;
12793 int res3 = 0 ;
12794 unsigned char temp4 ;
12795 int res4 = 0 ;
12796 PyObject * obj0 = 0 ;
12797 char *kwnames[] = {
12798 (char *) "self", NULL
12799 };
12800
12801 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12802 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12803 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12806 if (SWIG_arg_fail(1)) SWIG_fail;
12807 {
12808 PyThreadState* __tstate = wxPyBeginAllowThreads();
12809 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12810
12811 wxPyEndAllowThreads(__tstate);
12812 if (PyErr_Occurred()) SWIG_fail;
12813 }
12814 Py_INCREF(Py_None); resultobj = Py_None;
12815 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12816 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12817 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12818 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12819 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12820 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12828 PyObject *resultobj;
12829 wxImage *arg1 = (wxImage *) 0 ;
12830 unsigned char result;
12831 PyObject * obj0 = 0 ;
12832 char *kwnames[] = {
12833 (char *) "self", NULL
12834 };
12835
12836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12838 if (SWIG_arg_fail(1)) SWIG_fail;
12839 {
12840 PyThreadState* __tstate = wxPyBeginAllowThreads();
12841 result = (unsigned char)(arg1)->GetMaskRed();
12842
12843 wxPyEndAllowThreads(__tstate);
12844 if (PyErr_Occurred()) SWIG_fail;
12845 }
12846 {
12847 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12848 }
12849 return resultobj;
12850 fail:
12851 return NULL;
12852 }
12853
12854
12855 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12856 PyObject *resultobj;
12857 wxImage *arg1 = (wxImage *) 0 ;
12858 unsigned char result;
12859 PyObject * obj0 = 0 ;
12860 char *kwnames[] = {
12861 (char *) "self", NULL
12862 };
12863
12864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12866 if (SWIG_arg_fail(1)) SWIG_fail;
12867 {
12868 PyThreadState* __tstate = wxPyBeginAllowThreads();
12869 result = (unsigned char)(arg1)->GetMaskGreen();
12870
12871 wxPyEndAllowThreads(__tstate);
12872 if (PyErr_Occurred()) SWIG_fail;
12873 }
12874 {
12875 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12876 }
12877 return resultobj;
12878 fail:
12879 return NULL;
12880 }
12881
12882
12883 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12884 PyObject *resultobj;
12885 wxImage *arg1 = (wxImage *) 0 ;
12886 unsigned char result;
12887 PyObject * obj0 = 0 ;
12888 char *kwnames[] = {
12889 (char *) "self", NULL
12890 };
12891
12892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12894 if (SWIG_arg_fail(1)) SWIG_fail;
12895 {
12896 PyThreadState* __tstate = wxPyBeginAllowThreads();
12897 result = (unsigned char)(arg1)->GetMaskBlue();
12898
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 {
12903 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12904 }
12905 return resultobj;
12906 fail:
12907 return NULL;
12908 }
12909
12910
12911 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12912 PyObject *resultobj;
12913 wxImage *arg1 = (wxImage *) 0 ;
12914 bool arg2 = (bool) true ;
12915 PyObject * obj0 = 0 ;
12916 PyObject * obj1 = 0 ;
12917 char *kwnames[] = {
12918 (char *) "self",(char *) "mask", NULL
12919 };
12920
12921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12923 if (SWIG_arg_fail(1)) SWIG_fail;
12924 if (obj1) {
12925 {
12926 arg2 = (bool)(SWIG_As_bool(obj1));
12927 if (SWIG_arg_fail(2)) SWIG_fail;
12928 }
12929 }
12930 {
12931 PyThreadState* __tstate = wxPyBeginAllowThreads();
12932 (arg1)->SetMask(arg2);
12933
12934 wxPyEndAllowThreads(__tstate);
12935 if (PyErr_Occurred()) SWIG_fail;
12936 }
12937 Py_INCREF(Py_None); resultobj = Py_None;
12938 return resultobj;
12939 fail:
12940 return NULL;
12941 }
12942
12943
12944 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12945 PyObject *resultobj;
12946 wxImage *arg1 = (wxImage *) 0 ;
12947 bool result;
12948 PyObject * obj0 = 0 ;
12949 char *kwnames[] = {
12950 (char *) "self", NULL
12951 };
12952
12953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12955 if (SWIG_arg_fail(1)) SWIG_fail;
12956 {
12957 PyThreadState* __tstate = wxPyBeginAllowThreads();
12958 result = (bool)(arg1)->HasMask();
12959
12960 wxPyEndAllowThreads(__tstate);
12961 if (PyErr_Occurred()) SWIG_fail;
12962 }
12963 {
12964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12965 }
12966 return resultobj;
12967 fail:
12968 return NULL;
12969 }
12970
12971
12972 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12973 PyObject *resultobj;
12974 wxImage *arg1 = (wxImage *) 0 ;
12975 double arg2 ;
12976 wxPoint *arg3 = 0 ;
12977 bool arg4 = (bool) true ;
12978 wxPoint *arg5 = (wxPoint *) NULL ;
12979 SwigValueWrapper<wxImage > result;
12980 wxPoint temp3 ;
12981 PyObject * obj0 = 0 ;
12982 PyObject * obj1 = 0 ;
12983 PyObject * obj2 = 0 ;
12984 PyObject * obj3 = 0 ;
12985 PyObject * obj4 = 0 ;
12986 char *kwnames[] = {
12987 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12988 };
12989
12990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12992 if (SWIG_arg_fail(1)) SWIG_fail;
12993 {
12994 arg2 = (double)(SWIG_As_double(obj1));
12995 if (SWIG_arg_fail(2)) SWIG_fail;
12996 }
12997 {
12998 arg3 = &temp3;
12999 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13000 }
13001 if (obj3) {
13002 {
13003 arg4 = (bool)(SWIG_As_bool(obj3));
13004 if (SWIG_arg_fail(4)) SWIG_fail;
13005 }
13006 }
13007 if (obj4) {
13008 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13009 if (SWIG_arg_fail(5)) SWIG_fail;
13010 }
13011 {
13012 PyThreadState* __tstate = wxPyBeginAllowThreads();
13013 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13014
13015 wxPyEndAllowThreads(__tstate);
13016 if (PyErr_Occurred()) SWIG_fail;
13017 }
13018 {
13019 wxImage * resultptr;
13020 resultptr = new wxImage((wxImage &)(result));
13021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13022 }
13023 return resultobj;
13024 fail:
13025 return NULL;
13026 }
13027
13028
13029 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13030 PyObject *resultobj;
13031 wxImage *arg1 = (wxImage *) 0 ;
13032 bool arg2 = (bool) true ;
13033 SwigValueWrapper<wxImage > result;
13034 PyObject * obj0 = 0 ;
13035 PyObject * obj1 = 0 ;
13036 char *kwnames[] = {
13037 (char *) "self",(char *) "clockwise", NULL
13038 };
13039
13040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13042 if (SWIG_arg_fail(1)) SWIG_fail;
13043 if (obj1) {
13044 {
13045 arg2 = (bool)(SWIG_As_bool(obj1));
13046 if (SWIG_arg_fail(2)) SWIG_fail;
13047 }
13048 }
13049 {
13050 PyThreadState* __tstate = wxPyBeginAllowThreads();
13051 result = (arg1)->Rotate90(arg2);
13052
13053 wxPyEndAllowThreads(__tstate);
13054 if (PyErr_Occurred()) SWIG_fail;
13055 }
13056 {
13057 wxImage * resultptr;
13058 resultptr = new wxImage((wxImage &)(result));
13059 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13060 }
13061 return resultobj;
13062 fail:
13063 return NULL;
13064 }
13065
13066
13067 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj;
13069 wxImage *arg1 = (wxImage *) 0 ;
13070 bool arg2 = (bool) true ;
13071 SwigValueWrapper<wxImage > result;
13072 PyObject * obj0 = 0 ;
13073 PyObject * obj1 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self",(char *) "horizontally", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 if (obj1) {
13082 {
13083 arg2 = (bool)(SWIG_As_bool(obj1));
13084 if (SWIG_arg_fail(2)) SWIG_fail;
13085 }
13086 }
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 result = (arg1)->Mirror(arg2);
13090
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 {
13095 wxImage * resultptr;
13096 resultptr = new wxImage((wxImage &)(result));
13097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13098 }
13099 return resultobj;
13100 fail:
13101 return NULL;
13102 }
13103
13104
13105 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13106 PyObject *resultobj;
13107 wxImage *arg1 = (wxImage *) 0 ;
13108 unsigned char arg2 ;
13109 unsigned char arg3 ;
13110 unsigned char arg4 ;
13111 unsigned char arg5 ;
13112 unsigned char arg6 ;
13113 unsigned char arg7 ;
13114 PyObject * obj0 = 0 ;
13115 PyObject * obj1 = 0 ;
13116 PyObject * obj2 = 0 ;
13117 PyObject * obj3 = 0 ;
13118 PyObject * obj4 = 0 ;
13119 PyObject * obj5 = 0 ;
13120 PyObject * obj6 = 0 ;
13121 char *kwnames[] = {
13122 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13123 };
13124
13125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13127 if (SWIG_arg_fail(1)) SWIG_fail;
13128 {
13129 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13130 if (SWIG_arg_fail(2)) SWIG_fail;
13131 }
13132 {
13133 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13134 if (SWIG_arg_fail(3)) SWIG_fail;
13135 }
13136 {
13137 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13138 if (SWIG_arg_fail(4)) SWIG_fail;
13139 }
13140 {
13141 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13142 if (SWIG_arg_fail(5)) SWIG_fail;
13143 }
13144 {
13145 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13146 if (SWIG_arg_fail(6)) SWIG_fail;
13147 }
13148 {
13149 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13150 if (SWIG_arg_fail(7)) SWIG_fail;
13151 }
13152 {
13153 PyThreadState* __tstate = wxPyBeginAllowThreads();
13154 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13155
13156 wxPyEndAllowThreads(__tstate);
13157 if (PyErr_Occurred()) SWIG_fail;
13158 }
13159 Py_INCREF(Py_None); resultobj = Py_None;
13160 return resultobj;
13161 fail:
13162 return NULL;
13163 }
13164
13165
13166 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13167 PyObject *resultobj;
13168 wxImage *arg1 = (wxImage *) 0 ;
13169 unsigned char arg2 ;
13170 unsigned char arg3 ;
13171 unsigned char arg4 ;
13172 SwigValueWrapper<wxImage > result;
13173 PyObject * obj0 = 0 ;
13174 PyObject * obj1 = 0 ;
13175 PyObject * obj2 = 0 ;
13176 PyObject * obj3 = 0 ;
13177 char *kwnames[] = {
13178 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13179 };
13180
13181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13183 if (SWIG_arg_fail(1)) SWIG_fail;
13184 {
13185 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13186 if (SWIG_arg_fail(2)) SWIG_fail;
13187 }
13188 {
13189 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13190 if (SWIG_arg_fail(3)) SWIG_fail;
13191 }
13192 {
13193 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13194 if (SWIG_arg_fail(4)) SWIG_fail;
13195 }
13196 {
13197 PyThreadState* __tstate = wxPyBeginAllowThreads();
13198 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13199
13200 wxPyEndAllowThreads(__tstate);
13201 if (PyErr_Occurred()) SWIG_fail;
13202 }
13203 {
13204 wxImage * resultptr;
13205 resultptr = new wxImage((wxImage &)(result));
13206 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13207 }
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj;
13216 wxImage *arg1 = (wxImage *) 0 ;
13217 wxString *arg2 = 0 ;
13218 wxString *arg3 = 0 ;
13219 bool temp2 = false ;
13220 bool temp3 = false ;
13221 PyObject * obj0 = 0 ;
13222 PyObject * obj1 = 0 ;
13223 PyObject * obj2 = 0 ;
13224 char *kwnames[] = {
13225 (char *) "self",(char *) "name",(char *) "value", NULL
13226 };
13227
13228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13230 if (SWIG_arg_fail(1)) SWIG_fail;
13231 {
13232 arg2 = wxString_in_helper(obj1);
13233 if (arg2 == NULL) SWIG_fail;
13234 temp2 = true;
13235 }
13236 {
13237 arg3 = wxString_in_helper(obj2);
13238 if (arg3 == NULL) SWIG_fail;
13239 temp3 = true;
13240 }
13241 {
13242 PyThreadState* __tstate = wxPyBeginAllowThreads();
13243 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13244
13245 wxPyEndAllowThreads(__tstate);
13246 if (PyErr_Occurred()) SWIG_fail;
13247 }
13248 Py_INCREF(Py_None); resultobj = Py_None;
13249 {
13250 if (temp2)
13251 delete arg2;
13252 }
13253 {
13254 if (temp3)
13255 delete arg3;
13256 }
13257 return resultobj;
13258 fail:
13259 {
13260 if (temp2)
13261 delete arg2;
13262 }
13263 {
13264 if (temp3)
13265 delete arg3;
13266 }
13267 return NULL;
13268 }
13269
13270
13271 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13272 PyObject *resultobj;
13273 wxImage *arg1 = (wxImage *) 0 ;
13274 wxString *arg2 = 0 ;
13275 int arg3 ;
13276 bool temp2 = false ;
13277 PyObject * obj0 = 0 ;
13278 PyObject * obj1 = 0 ;
13279 PyObject * obj2 = 0 ;
13280 char *kwnames[] = {
13281 (char *) "self",(char *) "name",(char *) "value", NULL
13282 };
13283
13284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13286 if (SWIG_arg_fail(1)) SWIG_fail;
13287 {
13288 arg2 = wxString_in_helper(obj1);
13289 if (arg2 == NULL) SWIG_fail;
13290 temp2 = true;
13291 }
13292 {
13293 arg3 = (int)(SWIG_As_int(obj2));
13294 if (SWIG_arg_fail(3)) SWIG_fail;
13295 }
13296 {
13297 PyThreadState* __tstate = wxPyBeginAllowThreads();
13298 (arg1)->SetOption((wxString const &)*arg2,arg3);
13299
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 Py_INCREF(Py_None); resultobj = Py_None;
13304 {
13305 if (temp2)
13306 delete arg2;
13307 }
13308 return resultobj;
13309 fail:
13310 {
13311 if (temp2)
13312 delete arg2;
13313 }
13314 return NULL;
13315 }
13316
13317
13318 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj;
13320 wxImage *arg1 = (wxImage *) 0 ;
13321 wxString *arg2 = 0 ;
13322 wxString result;
13323 bool temp2 = false ;
13324 PyObject * obj0 = 0 ;
13325 PyObject * obj1 = 0 ;
13326 char *kwnames[] = {
13327 (char *) "self",(char *) "name", NULL
13328 };
13329
13330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13332 if (SWIG_arg_fail(1)) SWIG_fail;
13333 {
13334 arg2 = wxString_in_helper(obj1);
13335 if (arg2 == NULL) SWIG_fail;
13336 temp2 = true;
13337 }
13338 {
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13341
13342 wxPyEndAllowThreads(__tstate);
13343 if (PyErr_Occurred()) SWIG_fail;
13344 }
13345 {
13346 #if wxUSE_UNICODE
13347 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13348 #else
13349 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13350 #endif
13351 }
13352 {
13353 if (temp2)
13354 delete arg2;
13355 }
13356 return resultobj;
13357 fail:
13358 {
13359 if (temp2)
13360 delete arg2;
13361 }
13362 return NULL;
13363 }
13364
13365
13366 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13367 PyObject *resultobj;
13368 wxImage *arg1 = (wxImage *) 0 ;
13369 wxString *arg2 = 0 ;
13370 int result;
13371 bool temp2 = false ;
13372 PyObject * obj0 = 0 ;
13373 PyObject * obj1 = 0 ;
13374 char *kwnames[] = {
13375 (char *) "self",(char *) "name", NULL
13376 };
13377
13378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13380 if (SWIG_arg_fail(1)) SWIG_fail;
13381 {
13382 arg2 = wxString_in_helper(obj1);
13383 if (arg2 == NULL) SWIG_fail;
13384 temp2 = true;
13385 }
13386 {
13387 PyThreadState* __tstate = wxPyBeginAllowThreads();
13388 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13389
13390 wxPyEndAllowThreads(__tstate);
13391 if (PyErr_Occurred()) SWIG_fail;
13392 }
13393 {
13394 resultobj = SWIG_From_int((int)(result));
13395 }
13396 {
13397 if (temp2)
13398 delete arg2;
13399 }
13400 return resultobj;
13401 fail:
13402 {
13403 if (temp2)
13404 delete arg2;
13405 }
13406 return NULL;
13407 }
13408
13409
13410 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13411 PyObject *resultobj;
13412 wxImage *arg1 = (wxImage *) 0 ;
13413 wxString *arg2 = 0 ;
13414 bool result;
13415 bool temp2 = false ;
13416 PyObject * obj0 = 0 ;
13417 PyObject * obj1 = 0 ;
13418 char *kwnames[] = {
13419 (char *) "self",(char *) "name", NULL
13420 };
13421
13422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13424 if (SWIG_arg_fail(1)) SWIG_fail;
13425 {
13426 arg2 = wxString_in_helper(obj1);
13427 if (arg2 == NULL) SWIG_fail;
13428 temp2 = true;
13429 }
13430 {
13431 PyThreadState* __tstate = wxPyBeginAllowThreads();
13432 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13433
13434 wxPyEndAllowThreads(__tstate);
13435 if (PyErr_Occurred()) SWIG_fail;
13436 }
13437 {
13438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13439 }
13440 {
13441 if (temp2)
13442 delete arg2;
13443 }
13444 return resultobj;
13445 fail:
13446 {
13447 if (temp2)
13448 delete arg2;
13449 }
13450 return NULL;
13451 }
13452
13453
13454 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13455 PyObject *resultobj;
13456 wxImage *arg1 = (wxImage *) 0 ;
13457 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13458 unsigned long result;
13459 PyObject * obj0 = 0 ;
13460 PyObject * obj1 = 0 ;
13461 char *kwnames[] = {
13462 (char *) "self",(char *) "stopafter", NULL
13463 };
13464
13465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13467 if (SWIG_arg_fail(1)) SWIG_fail;
13468 if (obj1) {
13469 {
13470 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13471 if (SWIG_arg_fail(2)) SWIG_fail;
13472 }
13473 }
13474 {
13475 PyThreadState* __tstate = wxPyBeginAllowThreads();
13476 result = (unsigned long)(arg1)->CountColours(arg2);
13477
13478 wxPyEndAllowThreads(__tstate);
13479 if (PyErr_Occurred()) SWIG_fail;
13480 }
13481 {
13482 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13483 }
13484 return resultobj;
13485 fail:
13486 return NULL;
13487 }
13488
13489
13490 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13491 PyObject *resultobj;
13492 wxImage *arg1 = (wxImage *) 0 ;
13493 wxImageHistogram *arg2 = 0 ;
13494 unsigned long result;
13495 PyObject * obj0 = 0 ;
13496 PyObject * obj1 = 0 ;
13497 char *kwnames[] = {
13498 (char *) "self",(char *) "h", NULL
13499 };
13500
13501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13503 if (SWIG_arg_fail(1)) SWIG_fail;
13504 {
13505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13506 if (SWIG_arg_fail(2)) SWIG_fail;
13507 if (arg2 == NULL) {
13508 SWIG_null_ref("wxImageHistogram");
13509 }
13510 if (SWIG_arg_fail(2)) SWIG_fail;
13511 }
13512 {
13513 PyThreadState* __tstate = wxPyBeginAllowThreads();
13514 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13515
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 {
13520 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13521 }
13522 return resultobj;
13523 fail:
13524 return NULL;
13525 }
13526
13527
13528 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13529 PyObject *resultobj;
13530 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13531 PyObject * obj0 = 0 ;
13532 char *kwnames[] = {
13533 (char *) "handler", NULL
13534 };
13535
13536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13538 if (SWIG_arg_fail(1)) SWIG_fail;
13539 {
13540 PyThreadState* __tstate = wxPyBeginAllowThreads();
13541 wxImage::AddHandler(arg1);
13542
13543 wxPyEndAllowThreads(__tstate);
13544 if (PyErr_Occurred()) SWIG_fail;
13545 }
13546 Py_INCREF(Py_None); resultobj = Py_None;
13547 return resultobj;
13548 fail:
13549 return NULL;
13550 }
13551
13552
13553 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13554 PyObject *resultobj;
13555 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13556 PyObject * obj0 = 0 ;
13557 char *kwnames[] = {
13558 (char *) "handler", NULL
13559 };
13560
13561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13563 if (SWIG_arg_fail(1)) SWIG_fail;
13564 {
13565 PyThreadState* __tstate = wxPyBeginAllowThreads();
13566 wxImage::InsertHandler(arg1);
13567
13568 wxPyEndAllowThreads(__tstate);
13569 if (PyErr_Occurred()) SWIG_fail;
13570 }
13571 Py_INCREF(Py_None); resultobj = Py_None;
13572 return resultobj;
13573 fail:
13574 return NULL;
13575 }
13576
13577
13578 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13579 PyObject *resultobj;
13580 wxString *arg1 = 0 ;
13581 bool result;
13582 bool temp1 = false ;
13583 PyObject * obj0 = 0 ;
13584 char *kwnames[] = {
13585 (char *) "name", NULL
13586 };
13587
13588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13589 {
13590 arg1 = wxString_in_helper(obj0);
13591 if (arg1 == NULL) SWIG_fail;
13592 temp1 = true;
13593 }
13594 {
13595 PyThreadState* __tstate = wxPyBeginAllowThreads();
13596 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13597
13598 wxPyEndAllowThreads(__tstate);
13599 if (PyErr_Occurred()) SWIG_fail;
13600 }
13601 {
13602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13603 }
13604 {
13605 if (temp1)
13606 delete arg1;
13607 }
13608 return resultobj;
13609 fail:
13610 {
13611 if (temp1)
13612 delete arg1;
13613 }
13614 return NULL;
13615 }
13616
13617
13618 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj;
13620 wxString result;
13621 char *kwnames[] = {
13622 NULL
13623 };
13624
13625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13626 {
13627 PyThreadState* __tstate = wxPyBeginAllowThreads();
13628 result = wxImage::GetImageExtWildcard();
13629
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 {
13634 #if wxUSE_UNICODE
13635 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13636 #else
13637 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13638 #endif
13639 }
13640 return resultobj;
13641 fail:
13642 return NULL;
13643 }
13644
13645
13646 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13647 PyObject *resultobj;
13648 wxImage *arg1 = (wxImage *) 0 ;
13649 int arg2 = (int) -1 ;
13650 wxBitmap result;
13651 PyObject * obj0 = 0 ;
13652 PyObject * obj1 = 0 ;
13653 char *kwnames[] = {
13654 (char *) "self",(char *) "depth", NULL
13655 };
13656
13657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13659 if (SWIG_arg_fail(1)) SWIG_fail;
13660 if (obj1) {
13661 {
13662 arg2 = (int)(SWIG_As_int(obj1));
13663 if (SWIG_arg_fail(2)) SWIG_fail;
13664 }
13665 }
13666 {
13667 if (!wxPyCheckForApp()) SWIG_fail;
13668 PyThreadState* __tstate = wxPyBeginAllowThreads();
13669 result = wxImage_ConvertToBitmap(arg1,arg2);
13670
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 {
13675 wxBitmap * resultptr;
13676 resultptr = new wxBitmap((wxBitmap &)(result));
13677 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13678 }
13679 return resultobj;
13680 fail:
13681 return NULL;
13682 }
13683
13684
13685 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj;
13687 wxImage *arg1 = (wxImage *) 0 ;
13688 unsigned char arg2 ;
13689 unsigned char arg3 ;
13690 unsigned char arg4 ;
13691 wxBitmap result;
13692 PyObject * obj0 = 0 ;
13693 PyObject * obj1 = 0 ;
13694 PyObject * obj2 = 0 ;
13695 PyObject * obj3 = 0 ;
13696 char *kwnames[] = {
13697 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13698 };
13699
13700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13702 if (SWIG_arg_fail(1)) SWIG_fail;
13703 {
13704 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13705 if (SWIG_arg_fail(2)) SWIG_fail;
13706 }
13707 {
13708 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13709 if (SWIG_arg_fail(3)) SWIG_fail;
13710 }
13711 {
13712 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13713 if (SWIG_arg_fail(4)) SWIG_fail;
13714 }
13715 {
13716 if (!wxPyCheckForApp()) SWIG_fail;
13717 PyThreadState* __tstate = wxPyBeginAllowThreads();
13718 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13719
13720 wxPyEndAllowThreads(__tstate);
13721 if (PyErr_Occurred()) SWIG_fail;
13722 }
13723 {
13724 wxBitmap * resultptr;
13725 resultptr = new wxBitmap((wxBitmap &)(result));
13726 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13727 }
13728 return resultobj;
13729 fail:
13730 return NULL;
13731 }
13732
13733
13734 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13735 PyObject *obj;
13736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13737 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13738 Py_INCREF(obj);
13739 return Py_BuildValue((char *)"");
13740 }
13741 static int _wrap_NullImage_set(PyObject *) {
13742 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13743 return 1;
13744 }
13745
13746
13747 static PyObject *_wrap_NullImage_get(void) {
13748 PyObject *pyobj;
13749
13750 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13751 return pyobj;
13752 }
13753
13754
13755 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13756 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13757 return 1;
13758 }
13759
13760
13761 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13762 PyObject *pyobj;
13763
13764 {
13765 #if wxUSE_UNICODE
13766 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13767 #else
13768 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13769 #endif
13770 }
13771 return pyobj;
13772 }
13773
13774
13775 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13776 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13777 return 1;
13778 }
13779
13780
13781 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13782 PyObject *pyobj;
13783
13784 {
13785 #if wxUSE_UNICODE
13786 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13787 #else
13788 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13789 #endif
13790 }
13791 return pyobj;
13792 }
13793
13794
13795 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13796 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13797 return 1;
13798 }
13799
13800
13801 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13802 PyObject *pyobj;
13803
13804 {
13805 #if wxUSE_UNICODE
13806 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13807 #else
13808 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13809 #endif
13810 }
13811 return pyobj;
13812 }
13813
13814
13815 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13816 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13817 return 1;
13818 }
13819
13820
13821 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13822 PyObject *pyobj;
13823
13824 {
13825 #if wxUSE_UNICODE
13826 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13827 #else
13828 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13829 #endif
13830 }
13831 return pyobj;
13832 }
13833
13834
13835 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13836 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13837 return 1;
13838 }
13839
13840
13841 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13842 PyObject *pyobj;
13843
13844 {
13845 #if wxUSE_UNICODE
13846 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13847 #else
13848 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13849 #endif
13850 }
13851 return pyobj;
13852 }
13853
13854
13855 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13856 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13857 return 1;
13858 }
13859
13860
13861 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13862 PyObject *pyobj;
13863
13864 {
13865 #if wxUSE_UNICODE
13866 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13867 #else
13868 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13869 #endif
13870 }
13871 return pyobj;
13872 }
13873
13874
13875 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13876 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13877 return 1;
13878 }
13879
13880
13881 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13882 PyObject *pyobj;
13883
13884 {
13885 #if wxUSE_UNICODE
13886 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13887 #else
13888 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13889 #endif
13890 }
13891 return pyobj;
13892 }
13893
13894
13895 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13896 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13897 return 1;
13898 }
13899
13900
13901 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13902 PyObject *pyobj;
13903
13904 {
13905 #if wxUSE_UNICODE
13906 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13907 #else
13908 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13909 #endif
13910 }
13911 return pyobj;
13912 }
13913
13914
13915 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13916 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13917 return 1;
13918 }
13919
13920
13921 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13922 PyObject *pyobj;
13923
13924 {
13925 #if wxUSE_UNICODE
13926 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13927 #else
13928 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13929 #endif
13930 }
13931 return pyobj;
13932 }
13933
13934
13935 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13936 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13937 return 1;
13938 }
13939
13940
13941 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13942 PyObject *pyobj;
13943
13944 {
13945 #if wxUSE_UNICODE
13946 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13947 #else
13948 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13949 #endif
13950 }
13951 return pyobj;
13952 }
13953
13954
13955 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13956 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13957 return 1;
13958 }
13959
13960
13961 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13962 PyObject *pyobj;
13963
13964 {
13965 #if wxUSE_UNICODE
13966 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13967 #else
13968 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13969 #endif
13970 }
13971 return pyobj;
13972 }
13973
13974
13975 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13976 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13977 return 1;
13978 }
13979
13980
13981 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13982 PyObject *pyobj;
13983
13984 {
13985 #if wxUSE_UNICODE
13986 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13987 #else
13988 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13989 #endif
13990 }
13991 return pyobj;
13992 }
13993
13994
13995 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13996 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13997 return 1;
13998 }
13999
14000
14001 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14002 PyObject *pyobj;
14003
14004 {
14005 #if wxUSE_UNICODE
14006 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14007 #else
14008 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14009 #endif
14010 }
14011 return pyobj;
14012 }
14013
14014
14015 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14016 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14017 return 1;
14018 }
14019
14020
14021 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14022 PyObject *pyobj;
14023
14024 {
14025 #if wxUSE_UNICODE
14026 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14027 #else
14028 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14029 #endif
14030 }
14031 return pyobj;
14032 }
14033
14034
14035 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14036 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14037 return 1;
14038 }
14039
14040
14041 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14042 PyObject *pyobj;
14043
14044 {
14045 #if wxUSE_UNICODE
14046 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14047 #else
14048 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14049 #endif
14050 }
14051 return pyobj;
14052 }
14053
14054
14055 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14056 PyObject *resultobj;
14057 wxBMPHandler *result;
14058 char *kwnames[] = {
14059 NULL
14060 };
14061
14062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14063 {
14064 PyThreadState* __tstate = wxPyBeginAllowThreads();
14065 result = (wxBMPHandler *)new wxBMPHandler();
14066
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14071 return resultobj;
14072 fail:
14073 return NULL;
14074 }
14075
14076
14077 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14078 PyObject *obj;
14079 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14080 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14081 Py_INCREF(obj);
14082 return Py_BuildValue((char *)"");
14083 }
14084 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14085 PyObject *resultobj;
14086 wxICOHandler *result;
14087 char *kwnames[] = {
14088 NULL
14089 };
14090
14091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 result = (wxICOHandler *)new wxICOHandler();
14095
14096 wxPyEndAllowThreads(__tstate);
14097 if (PyErr_Occurred()) SWIG_fail;
14098 }
14099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14100 return resultobj;
14101 fail:
14102 return NULL;
14103 }
14104
14105
14106 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14107 PyObject *obj;
14108 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14109 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14110 Py_INCREF(obj);
14111 return Py_BuildValue((char *)"");
14112 }
14113 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj;
14115 wxCURHandler *result;
14116 char *kwnames[] = {
14117 NULL
14118 };
14119
14120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14121 {
14122 PyThreadState* __tstate = wxPyBeginAllowThreads();
14123 result = (wxCURHandler *)new wxCURHandler();
14124
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14129 return resultobj;
14130 fail:
14131 return NULL;
14132 }
14133
14134
14135 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14136 PyObject *obj;
14137 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14138 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14139 Py_INCREF(obj);
14140 return Py_BuildValue((char *)"");
14141 }
14142 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj;
14144 wxANIHandler *result;
14145 char *kwnames[] = {
14146 NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14150 {
14151 PyThreadState* __tstate = wxPyBeginAllowThreads();
14152 result = (wxANIHandler *)new wxANIHandler();
14153
14154 wxPyEndAllowThreads(__tstate);
14155 if (PyErr_Occurred()) SWIG_fail;
14156 }
14157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14158 return resultobj;
14159 fail:
14160 return NULL;
14161 }
14162
14163
14164 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14165 PyObject *obj;
14166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14167 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14168 Py_INCREF(obj);
14169 return Py_BuildValue((char *)"");
14170 }
14171 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14172 PyObject *resultobj;
14173 wxPNGHandler *result;
14174 char *kwnames[] = {
14175 NULL
14176 };
14177
14178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14179 {
14180 PyThreadState* __tstate = wxPyBeginAllowThreads();
14181 result = (wxPNGHandler *)new wxPNGHandler();
14182
14183 wxPyEndAllowThreads(__tstate);
14184 if (PyErr_Occurred()) SWIG_fail;
14185 }
14186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14187 return resultobj;
14188 fail:
14189 return NULL;
14190 }
14191
14192
14193 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14194 PyObject *obj;
14195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14196 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14197 Py_INCREF(obj);
14198 return Py_BuildValue((char *)"");
14199 }
14200 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14201 PyObject *resultobj;
14202 wxGIFHandler *result;
14203 char *kwnames[] = {
14204 NULL
14205 };
14206
14207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 result = (wxGIFHandler *)new wxGIFHandler();
14211
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14216 return resultobj;
14217 fail:
14218 return NULL;
14219 }
14220
14221
14222 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14223 PyObject *obj;
14224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14225 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14226 Py_INCREF(obj);
14227 return Py_BuildValue((char *)"");
14228 }
14229 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14230 PyObject *resultobj;
14231 wxPCXHandler *result;
14232 char *kwnames[] = {
14233 NULL
14234 };
14235
14236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14237 {
14238 PyThreadState* __tstate = wxPyBeginAllowThreads();
14239 result = (wxPCXHandler *)new wxPCXHandler();
14240
14241 wxPyEndAllowThreads(__tstate);
14242 if (PyErr_Occurred()) SWIG_fail;
14243 }
14244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14245 return resultobj;
14246 fail:
14247 return NULL;
14248 }
14249
14250
14251 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14252 PyObject *obj;
14253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14254 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14255 Py_INCREF(obj);
14256 return Py_BuildValue((char *)"");
14257 }
14258 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14259 PyObject *resultobj;
14260 wxJPEGHandler *result;
14261 char *kwnames[] = {
14262 NULL
14263 };
14264
14265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 result = (wxJPEGHandler *)new wxJPEGHandler();
14269
14270 wxPyEndAllowThreads(__tstate);
14271 if (PyErr_Occurred()) SWIG_fail;
14272 }
14273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14281 PyObject *obj;
14282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14283 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14284 Py_INCREF(obj);
14285 return Py_BuildValue((char *)"");
14286 }
14287 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj;
14289 wxPNMHandler *result;
14290 char *kwnames[] = {
14291 NULL
14292 };
14293
14294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14295 {
14296 PyThreadState* __tstate = wxPyBeginAllowThreads();
14297 result = (wxPNMHandler *)new wxPNMHandler();
14298
14299 wxPyEndAllowThreads(__tstate);
14300 if (PyErr_Occurred()) SWIG_fail;
14301 }
14302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14303 return resultobj;
14304 fail:
14305 return NULL;
14306 }
14307
14308
14309 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14310 PyObject *obj;
14311 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14312 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14313 Py_INCREF(obj);
14314 return Py_BuildValue((char *)"");
14315 }
14316 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14317 PyObject *resultobj;
14318 wxXPMHandler *result;
14319 char *kwnames[] = {
14320 NULL
14321 };
14322
14323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 result = (wxXPMHandler *)new wxXPMHandler();
14327
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14339 PyObject *obj;
14340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14341 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14342 Py_INCREF(obj);
14343 return Py_BuildValue((char *)"");
14344 }
14345 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14346 PyObject *resultobj;
14347 wxTIFFHandler *result;
14348 char *kwnames[] = {
14349 NULL
14350 };
14351
14352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 result = (wxTIFFHandler *)new wxTIFFHandler();
14356
14357 wxPyEndAllowThreads(__tstate);
14358 if (PyErr_Occurred()) SWIG_fail;
14359 }
14360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14361 return resultobj;
14362 fail:
14363 return NULL;
14364 }
14365
14366
14367 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14368 PyObject *obj;
14369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14370 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14371 Py_INCREF(obj);
14372 return Py_BuildValue((char *)"");
14373 }
14374 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14375 PyObject *resultobj;
14376 wxImage *arg1 = 0 ;
14377 wxImage *arg2 = 0 ;
14378 int arg3 = (int) 236 ;
14379 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14380 bool result;
14381 PyObject * obj0 = 0 ;
14382 PyObject * obj1 = 0 ;
14383 PyObject * obj2 = 0 ;
14384 PyObject * obj3 = 0 ;
14385 char *kwnames[] = {
14386 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14387 };
14388
14389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14390 {
14391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14392 if (SWIG_arg_fail(1)) SWIG_fail;
14393 if (arg1 == NULL) {
14394 SWIG_null_ref("wxImage");
14395 }
14396 if (SWIG_arg_fail(1)) SWIG_fail;
14397 }
14398 {
14399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14400 if (SWIG_arg_fail(2)) SWIG_fail;
14401 if (arg2 == NULL) {
14402 SWIG_null_ref("wxImage");
14403 }
14404 if (SWIG_arg_fail(2)) SWIG_fail;
14405 }
14406 if (obj2) {
14407 {
14408 arg3 = (int)(SWIG_As_int(obj2));
14409 if (SWIG_arg_fail(3)) SWIG_fail;
14410 }
14411 }
14412 if (obj3) {
14413 {
14414 arg4 = (int)(SWIG_As_int(obj3));
14415 if (SWIG_arg_fail(4)) SWIG_fail;
14416 }
14417 }
14418 {
14419 PyThreadState* __tstate = wxPyBeginAllowThreads();
14420 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14421
14422 wxPyEndAllowThreads(__tstate);
14423 if (PyErr_Occurred()) SWIG_fail;
14424 }
14425 {
14426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14427 }
14428 return resultobj;
14429 fail:
14430 return NULL;
14431 }
14432
14433
14434 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14435 PyObject *obj;
14436 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14437 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14438 Py_INCREF(obj);
14439 return Py_BuildValue((char *)"");
14440 }
14441 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14442 PyObject *resultobj;
14443 wxEvtHandler *result;
14444 char *kwnames[] = {
14445 NULL
14446 };
14447
14448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14449 {
14450 PyThreadState* __tstate = wxPyBeginAllowThreads();
14451 result = (wxEvtHandler *)new wxEvtHandler();
14452
14453 wxPyEndAllowThreads(__tstate);
14454 if (PyErr_Occurred()) SWIG_fail;
14455 }
14456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14457 return resultobj;
14458 fail:
14459 return NULL;
14460 }
14461
14462
14463 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14464 PyObject *resultobj;
14465 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14466 wxEvtHandler *result;
14467 PyObject * obj0 = 0 ;
14468 char *kwnames[] = {
14469 (char *) "self", NULL
14470 };
14471
14472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14474 if (SWIG_arg_fail(1)) SWIG_fail;
14475 {
14476 PyThreadState* __tstate = wxPyBeginAllowThreads();
14477 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14478
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 {
14483 resultobj = wxPyMake_wxObject(result, 0);
14484 }
14485 return resultobj;
14486 fail:
14487 return NULL;
14488 }
14489
14490
14491 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14492 PyObject *resultobj;
14493 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14494 wxEvtHandler *result;
14495 PyObject * obj0 = 0 ;
14496 char *kwnames[] = {
14497 (char *) "self", NULL
14498 };
14499
14500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14502 if (SWIG_arg_fail(1)) SWIG_fail;
14503 {
14504 PyThreadState* __tstate = wxPyBeginAllowThreads();
14505 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14506
14507 wxPyEndAllowThreads(__tstate);
14508 if (PyErr_Occurred()) SWIG_fail;
14509 }
14510 {
14511 resultobj = wxPyMake_wxObject(result, 0);
14512 }
14513 return resultobj;
14514 fail:
14515 return NULL;
14516 }
14517
14518
14519 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14520 PyObject *resultobj;
14521 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14522 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14523 PyObject * obj0 = 0 ;
14524 PyObject * obj1 = 0 ;
14525 char *kwnames[] = {
14526 (char *) "self",(char *) "handler", NULL
14527 };
14528
14529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14531 if (SWIG_arg_fail(1)) SWIG_fail;
14532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14533 if (SWIG_arg_fail(2)) SWIG_fail;
14534 {
14535 PyThreadState* __tstate = wxPyBeginAllowThreads();
14536 (arg1)->SetNextHandler(arg2);
14537
14538 wxPyEndAllowThreads(__tstate);
14539 if (PyErr_Occurred()) SWIG_fail;
14540 }
14541 Py_INCREF(Py_None); resultobj = Py_None;
14542 return resultobj;
14543 fail:
14544 return NULL;
14545 }
14546
14547
14548 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14549 PyObject *resultobj;
14550 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14551 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14552 PyObject * obj0 = 0 ;
14553 PyObject * obj1 = 0 ;
14554 char *kwnames[] = {
14555 (char *) "self",(char *) "handler", NULL
14556 };
14557
14558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14560 if (SWIG_arg_fail(1)) SWIG_fail;
14561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14562 if (SWIG_arg_fail(2)) SWIG_fail;
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 (arg1)->SetPreviousHandler(arg2);
14566
14567 wxPyEndAllowThreads(__tstate);
14568 if (PyErr_Occurred()) SWIG_fail;
14569 }
14570 Py_INCREF(Py_None); resultobj = Py_None;
14571 return resultobj;
14572 fail:
14573 return NULL;
14574 }
14575
14576
14577 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14578 PyObject *resultobj;
14579 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14580 bool result;
14581 PyObject * obj0 = 0 ;
14582 char *kwnames[] = {
14583 (char *) "self", NULL
14584 };
14585
14586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14588 if (SWIG_arg_fail(1)) SWIG_fail;
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 result = (bool)(arg1)->GetEvtHandlerEnabled();
14592
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 {
14597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14598 }
14599 return resultobj;
14600 fail:
14601 return NULL;
14602 }
14603
14604
14605 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14606 PyObject *resultobj;
14607 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14608 bool arg2 ;
14609 PyObject * obj0 = 0 ;
14610 PyObject * obj1 = 0 ;
14611 char *kwnames[] = {
14612 (char *) "self",(char *) "enabled", NULL
14613 };
14614
14615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14617 if (SWIG_arg_fail(1)) SWIG_fail;
14618 {
14619 arg2 = (bool)(SWIG_As_bool(obj1));
14620 if (SWIG_arg_fail(2)) SWIG_fail;
14621 }
14622 {
14623 PyThreadState* __tstate = wxPyBeginAllowThreads();
14624 (arg1)->SetEvtHandlerEnabled(arg2);
14625
14626 wxPyEndAllowThreads(__tstate);
14627 if (PyErr_Occurred()) SWIG_fail;
14628 }
14629 Py_INCREF(Py_None); resultobj = Py_None;
14630 return resultobj;
14631 fail:
14632 return NULL;
14633 }
14634
14635
14636 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14637 PyObject *resultobj;
14638 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14639 wxEvent *arg2 = 0 ;
14640 bool result;
14641 PyObject * obj0 = 0 ;
14642 PyObject * obj1 = 0 ;
14643 char *kwnames[] = {
14644 (char *) "self",(char *) "event", NULL
14645 };
14646
14647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14649 if (SWIG_arg_fail(1)) SWIG_fail;
14650 {
14651 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14652 if (SWIG_arg_fail(2)) SWIG_fail;
14653 if (arg2 == NULL) {
14654 SWIG_null_ref("wxEvent");
14655 }
14656 if (SWIG_arg_fail(2)) SWIG_fail;
14657 }
14658 {
14659 PyThreadState* __tstate = wxPyBeginAllowThreads();
14660 result = (bool)(arg1)->ProcessEvent(*arg2);
14661
14662 wxPyEndAllowThreads(__tstate);
14663 if (PyErr_Occurred()) SWIG_fail;
14664 }
14665 {
14666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14667 }
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14675 PyObject *resultobj;
14676 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14677 wxEvent *arg2 = 0 ;
14678 PyObject * obj0 = 0 ;
14679 PyObject * obj1 = 0 ;
14680 char *kwnames[] = {
14681 (char *) "self",(char *) "event", NULL
14682 };
14683
14684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14686 if (SWIG_arg_fail(1)) SWIG_fail;
14687 {
14688 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14689 if (SWIG_arg_fail(2)) SWIG_fail;
14690 if (arg2 == NULL) {
14691 SWIG_null_ref("wxEvent");
14692 }
14693 if (SWIG_arg_fail(2)) SWIG_fail;
14694 }
14695 {
14696 PyThreadState* __tstate = wxPyBeginAllowThreads();
14697 (arg1)->AddPendingEvent(*arg2);
14698
14699 wxPyEndAllowThreads(__tstate);
14700 if (PyErr_Occurred()) SWIG_fail;
14701 }
14702 Py_INCREF(Py_None); resultobj = Py_None;
14703 return resultobj;
14704 fail:
14705 return NULL;
14706 }
14707
14708
14709 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14710 PyObject *resultobj;
14711 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14712 PyObject * obj0 = 0 ;
14713 char *kwnames[] = {
14714 (char *) "self", NULL
14715 };
14716
14717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14719 if (SWIG_arg_fail(1)) SWIG_fail;
14720 {
14721 PyThreadState* __tstate = wxPyBeginAllowThreads();
14722 (arg1)->ProcessPendingEvents();
14723
14724 wxPyEndAllowThreads(__tstate);
14725 if (PyErr_Occurred()) SWIG_fail;
14726 }
14727 Py_INCREF(Py_None); resultobj = Py_None;
14728 return resultobj;
14729 fail:
14730 return NULL;
14731 }
14732
14733
14734 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14735 PyObject *resultobj;
14736 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14737 int arg2 ;
14738 int arg3 ;
14739 int arg4 ;
14740 PyObject *arg5 = (PyObject *) 0 ;
14741 PyObject * obj0 = 0 ;
14742 PyObject * obj1 = 0 ;
14743 PyObject * obj2 = 0 ;
14744 PyObject * obj3 = 0 ;
14745 PyObject * obj4 = 0 ;
14746 char *kwnames[] = {
14747 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14748 };
14749
14750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14752 if (SWIG_arg_fail(1)) SWIG_fail;
14753 {
14754 arg2 = (int)(SWIG_As_int(obj1));
14755 if (SWIG_arg_fail(2)) SWIG_fail;
14756 }
14757 {
14758 arg3 = (int)(SWIG_As_int(obj2));
14759 if (SWIG_arg_fail(3)) SWIG_fail;
14760 }
14761 {
14762 arg4 = (int)(SWIG_As_int(obj3));
14763 if (SWIG_arg_fail(4)) SWIG_fail;
14764 }
14765 arg5 = obj4;
14766 {
14767 PyThreadState* __tstate = wxPyBeginAllowThreads();
14768 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14769
14770 wxPyEndAllowThreads(__tstate);
14771 if (PyErr_Occurred()) SWIG_fail;
14772 }
14773 Py_INCREF(Py_None); resultobj = Py_None;
14774 return resultobj;
14775 fail:
14776 return NULL;
14777 }
14778
14779
14780 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14781 PyObject *resultobj;
14782 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14783 int arg2 ;
14784 int arg3 = (int) -1 ;
14785 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14786 bool result;
14787 PyObject * obj0 = 0 ;
14788 PyObject * obj1 = 0 ;
14789 PyObject * obj2 = 0 ;
14790 PyObject * obj3 = 0 ;
14791 char *kwnames[] = {
14792 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14793 };
14794
14795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14797 if (SWIG_arg_fail(1)) SWIG_fail;
14798 {
14799 arg2 = (int)(SWIG_As_int(obj1));
14800 if (SWIG_arg_fail(2)) SWIG_fail;
14801 }
14802 if (obj2) {
14803 {
14804 arg3 = (int)(SWIG_As_int(obj2));
14805 if (SWIG_arg_fail(3)) SWIG_fail;
14806 }
14807 }
14808 if (obj3) {
14809 {
14810 arg4 = (wxEventType)(SWIG_As_int(obj3));
14811 if (SWIG_arg_fail(4)) SWIG_fail;
14812 }
14813 }
14814 {
14815 PyThreadState* __tstate = wxPyBeginAllowThreads();
14816 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14817
14818 wxPyEndAllowThreads(__tstate);
14819 if (PyErr_Occurred()) SWIG_fail;
14820 }
14821 {
14822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14823 }
14824 return resultobj;
14825 fail:
14826 return NULL;
14827 }
14828
14829
14830 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14831 PyObject *resultobj;
14832 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14833 PyObject *arg2 = (PyObject *) 0 ;
14834 bool arg3 = (bool) true ;
14835 PyObject * obj0 = 0 ;
14836 PyObject * obj1 = 0 ;
14837 PyObject * obj2 = 0 ;
14838 char *kwnames[] = {
14839 (char *) "self",(char *) "_self",(char *) "incref", NULL
14840 };
14841
14842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14844 if (SWIG_arg_fail(1)) SWIG_fail;
14845 arg2 = obj1;
14846 if (obj2) {
14847 {
14848 arg3 = (bool)(SWIG_As_bool(obj2));
14849 if (SWIG_arg_fail(3)) SWIG_fail;
14850 }
14851 }
14852 {
14853 PyThreadState* __tstate = wxPyBeginAllowThreads();
14854 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14855
14856 wxPyEndAllowThreads(__tstate);
14857 if (PyErr_Occurred()) SWIG_fail;
14858 }
14859 Py_INCREF(Py_None); resultobj = Py_None;
14860 return resultobj;
14861 fail:
14862 return NULL;
14863 }
14864
14865
14866 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14867 PyObject *obj;
14868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14869 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14870 Py_INCREF(obj);
14871 return Py_BuildValue((char *)"");
14872 }
14873 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14874 PyObject *resultobj;
14875 wxEventType result;
14876 char *kwnames[] = {
14877 NULL
14878 };
14879
14880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14881 {
14882 PyThreadState* __tstate = wxPyBeginAllowThreads();
14883 result = (wxEventType)wxNewEventType();
14884
14885 wxPyEndAllowThreads(__tstate);
14886 if (PyErr_Occurred()) SWIG_fail;
14887 }
14888 {
14889 resultobj = SWIG_From_int((int)(result));
14890 }
14891 return resultobj;
14892 fail:
14893 return NULL;
14894 }
14895
14896
14897 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14898 PyObject *resultobj;
14899 wxEvent *arg1 = (wxEvent *) 0 ;
14900 PyObject * obj0 = 0 ;
14901 char *kwnames[] = {
14902 (char *) "self", NULL
14903 };
14904
14905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14907 if (SWIG_arg_fail(1)) SWIG_fail;
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 delete arg1;
14911
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 Py_INCREF(Py_None); resultobj = Py_None;
14916 return resultobj;
14917 fail:
14918 return NULL;
14919 }
14920
14921
14922 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14923 PyObject *resultobj;
14924 wxEvent *arg1 = (wxEvent *) 0 ;
14925 wxEventType arg2 ;
14926 PyObject * obj0 = 0 ;
14927 PyObject * obj1 = 0 ;
14928 char *kwnames[] = {
14929 (char *) "self",(char *) "typ", NULL
14930 };
14931
14932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14934 if (SWIG_arg_fail(1)) SWIG_fail;
14935 {
14936 arg2 = (wxEventType)(SWIG_As_int(obj1));
14937 if (SWIG_arg_fail(2)) SWIG_fail;
14938 }
14939 {
14940 PyThreadState* __tstate = wxPyBeginAllowThreads();
14941 (arg1)->SetEventType(arg2);
14942
14943 wxPyEndAllowThreads(__tstate);
14944 if (PyErr_Occurred()) SWIG_fail;
14945 }
14946 Py_INCREF(Py_None); resultobj = Py_None;
14947 return resultobj;
14948 fail:
14949 return NULL;
14950 }
14951
14952
14953 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14954 PyObject *resultobj;
14955 wxEvent *arg1 = (wxEvent *) 0 ;
14956 wxEventType result;
14957 PyObject * obj0 = 0 ;
14958 char *kwnames[] = {
14959 (char *) "self", NULL
14960 };
14961
14962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14964 if (SWIG_arg_fail(1)) SWIG_fail;
14965 {
14966 PyThreadState* __tstate = wxPyBeginAllowThreads();
14967 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14968
14969 wxPyEndAllowThreads(__tstate);
14970 if (PyErr_Occurred()) SWIG_fail;
14971 }
14972 {
14973 resultobj = SWIG_From_int((int)(result));
14974 }
14975 return resultobj;
14976 fail:
14977 return NULL;
14978 }
14979
14980
14981 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14982 PyObject *resultobj;
14983 wxEvent *arg1 = (wxEvent *) 0 ;
14984 wxObject *result;
14985 PyObject * obj0 = 0 ;
14986 char *kwnames[] = {
14987 (char *) "self", NULL
14988 };
14989
14990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14992 if (SWIG_arg_fail(1)) SWIG_fail;
14993 {
14994 PyThreadState* __tstate = wxPyBeginAllowThreads();
14995 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14996
14997 wxPyEndAllowThreads(__tstate);
14998 if (PyErr_Occurred()) SWIG_fail;
14999 }
15000 {
15001 resultobj = wxPyMake_wxObject(result, 0);
15002 }
15003 return resultobj;
15004 fail:
15005 return NULL;
15006 }
15007
15008
15009 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15010 PyObject *resultobj;
15011 wxEvent *arg1 = (wxEvent *) 0 ;
15012 wxObject *arg2 = (wxObject *) 0 ;
15013 PyObject * obj0 = 0 ;
15014 PyObject * obj1 = 0 ;
15015 char *kwnames[] = {
15016 (char *) "self",(char *) "obj", NULL
15017 };
15018
15019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15021 if (SWIG_arg_fail(1)) SWIG_fail;
15022 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15023 if (SWIG_arg_fail(2)) SWIG_fail;
15024 {
15025 PyThreadState* __tstate = wxPyBeginAllowThreads();
15026 (arg1)->SetEventObject(arg2);
15027
15028 wxPyEndAllowThreads(__tstate);
15029 if (PyErr_Occurred()) SWIG_fail;
15030 }
15031 Py_INCREF(Py_None); resultobj = Py_None;
15032 return resultobj;
15033 fail:
15034 return NULL;
15035 }
15036
15037
15038 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15039 PyObject *resultobj;
15040 wxEvent *arg1 = (wxEvent *) 0 ;
15041 long result;
15042 PyObject * obj0 = 0 ;
15043 char *kwnames[] = {
15044 (char *) "self", NULL
15045 };
15046
15047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15049 if (SWIG_arg_fail(1)) SWIG_fail;
15050 {
15051 PyThreadState* __tstate = wxPyBeginAllowThreads();
15052 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15053
15054 wxPyEndAllowThreads(__tstate);
15055 if (PyErr_Occurred()) SWIG_fail;
15056 }
15057 {
15058 resultobj = SWIG_From_long((long)(result));
15059 }
15060 return resultobj;
15061 fail:
15062 return NULL;
15063 }
15064
15065
15066 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15067 PyObject *resultobj;
15068 wxEvent *arg1 = (wxEvent *) 0 ;
15069 long arg2 = (long) 0 ;
15070 PyObject * obj0 = 0 ;
15071 PyObject * obj1 = 0 ;
15072 char *kwnames[] = {
15073 (char *) "self",(char *) "ts", NULL
15074 };
15075
15076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15078 if (SWIG_arg_fail(1)) SWIG_fail;
15079 if (obj1) {
15080 {
15081 arg2 = (long)(SWIG_As_long(obj1));
15082 if (SWIG_arg_fail(2)) SWIG_fail;
15083 }
15084 }
15085 {
15086 PyThreadState* __tstate = wxPyBeginAllowThreads();
15087 (arg1)->SetTimestamp(arg2);
15088
15089 wxPyEndAllowThreads(__tstate);
15090 if (PyErr_Occurred()) SWIG_fail;
15091 }
15092 Py_INCREF(Py_None); resultobj = Py_None;
15093 return resultobj;
15094 fail:
15095 return NULL;
15096 }
15097
15098
15099 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15100 PyObject *resultobj;
15101 wxEvent *arg1 = (wxEvent *) 0 ;
15102 int result;
15103 PyObject * obj0 = 0 ;
15104 char *kwnames[] = {
15105 (char *) "self", NULL
15106 };
15107
15108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15110 if (SWIG_arg_fail(1)) SWIG_fail;
15111 {
15112 PyThreadState* __tstate = wxPyBeginAllowThreads();
15113 result = (int)((wxEvent const *)arg1)->GetId();
15114
15115 wxPyEndAllowThreads(__tstate);
15116 if (PyErr_Occurred()) SWIG_fail;
15117 }
15118 {
15119 resultobj = SWIG_From_int((int)(result));
15120 }
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15128 PyObject *resultobj;
15129 wxEvent *arg1 = (wxEvent *) 0 ;
15130 int arg2 ;
15131 PyObject * obj0 = 0 ;
15132 PyObject * obj1 = 0 ;
15133 char *kwnames[] = {
15134 (char *) "self",(char *) "Id", NULL
15135 };
15136
15137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15139 if (SWIG_arg_fail(1)) SWIG_fail;
15140 {
15141 arg2 = (int)(SWIG_As_int(obj1));
15142 if (SWIG_arg_fail(2)) SWIG_fail;
15143 }
15144 {
15145 PyThreadState* __tstate = wxPyBeginAllowThreads();
15146 (arg1)->SetId(arg2);
15147
15148 wxPyEndAllowThreads(__tstate);
15149 if (PyErr_Occurred()) SWIG_fail;
15150 }
15151 Py_INCREF(Py_None); resultobj = Py_None;
15152 return resultobj;
15153 fail:
15154 return NULL;
15155 }
15156
15157
15158 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15159 PyObject *resultobj;
15160 wxEvent *arg1 = (wxEvent *) 0 ;
15161 bool result;
15162 PyObject * obj0 = 0 ;
15163 char *kwnames[] = {
15164 (char *) "self", NULL
15165 };
15166
15167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15169 if (SWIG_arg_fail(1)) SWIG_fail;
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15173
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 {
15178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15179 }
15180 return resultobj;
15181 fail:
15182 return NULL;
15183 }
15184
15185
15186 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15187 PyObject *resultobj;
15188 wxEvent *arg1 = (wxEvent *) 0 ;
15189 bool arg2 = (bool) true ;
15190 PyObject * obj0 = 0 ;
15191 PyObject * obj1 = 0 ;
15192 char *kwnames[] = {
15193 (char *) "self",(char *) "skip", NULL
15194 };
15195
15196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15198 if (SWIG_arg_fail(1)) SWIG_fail;
15199 if (obj1) {
15200 {
15201 arg2 = (bool)(SWIG_As_bool(obj1));
15202 if (SWIG_arg_fail(2)) SWIG_fail;
15203 }
15204 }
15205 {
15206 PyThreadState* __tstate = wxPyBeginAllowThreads();
15207 (arg1)->Skip(arg2);
15208
15209 wxPyEndAllowThreads(__tstate);
15210 if (PyErr_Occurred()) SWIG_fail;
15211 }
15212 Py_INCREF(Py_None); resultobj = Py_None;
15213 return resultobj;
15214 fail:
15215 return NULL;
15216 }
15217
15218
15219 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj;
15221 wxEvent *arg1 = (wxEvent *) 0 ;
15222 bool result;
15223 PyObject * obj0 = 0 ;
15224 char *kwnames[] = {
15225 (char *) "self", NULL
15226 };
15227
15228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15230 if (SWIG_arg_fail(1)) SWIG_fail;
15231 {
15232 PyThreadState* __tstate = wxPyBeginAllowThreads();
15233 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15234
15235 wxPyEndAllowThreads(__tstate);
15236 if (PyErr_Occurred()) SWIG_fail;
15237 }
15238 {
15239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15240 }
15241 return resultobj;
15242 fail:
15243 return NULL;
15244 }
15245
15246
15247 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15248 PyObject *resultobj;
15249 wxEvent *arg1 = (wxEvent *) 0 ;
15250 bool result;
15251 PyObject * obj0 = 0 ;
15252 char *kwnames[] = {
15253 (char *) "self", NULL
15254 };
15255
15256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15258 if (SWIG_arg_fail(1)) SWIG_fail;
15259 {
15260 PyThreadState* __tstate = wxPyBeginAllowThreads();
15261 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15262
15263 wxPyEndAllowThreads(__tstate);
15264 if (PyErr_Occurred()) SWIG_fail;
15265 }
15266 {
15267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15268 }
15269 return resultobj;
15270 fail:
15271 return NULL;
15272 }
15273
15274
15275 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15276 PyObject *resultobj;
15277 wxEvent *arg1 = (wxEvent *) 0 ;
15278 int result;
15279 PyObject * obj0 = 0 ;
15280 char *kwnames[] = {
15281 (char *) "self", NULL
15282 };
15283
15284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15286 if (SWIG_arg_fail(1)) SWIG_fail;
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (int)(arg1)->StopPropagation();
15290
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 {
15295 resultobj = SWIG_From_int((int)(result));
15296 }
15297 return resultobj;
15298 fail:
15299 return NULL;
15300 }
15301
15302
15303 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15304 PyObject *resultobj;
15305 wxEvent *arg1 = (wxEvent *) 0 ;
15306 int arg2 ;
15307 PyObject * obj0 = 0 ;
15308 PyObject * obj1 = 0 ;
15309 char *kwnames[] = {
15310 (char *) "self",(char *) "propagationLevel", NULL
15311 };
15312
15313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15315 if (SWIG_arg_fail(1)) SWIG_fail;
15316 {
15317 arg2 = (int)(SWIG_As_int(obj1));
15318 if (SWIG_arg_fail(2)) SWIG_fail;
15319 }
15320 {
15321 PyThreadState* __tstate = wxPyBeginAllowThreads();
15322 (arg1)->ResumePropagation(arg2);
15323
15324 wxPyEndAllowThreads(__tstate);
15325 if (PyErr_Occurred()) SWIG_fail;
15326 }
15327 Py_INCREF(Py_None); resultobj = Py_None;
15328 return resultobj;
15329 fail:
15330 return NULL;
15331 }
15332
15333
15334 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15335 PyObject *resultobj;
15336 wxEvent *arg1 = (wxEvent *) 0 ;
15337 wxEvent *result;
15338 PyObject * obj0 = 0 ;
15339 char *kwnames[] = {
15340 (char *) "self", NULL
15341 };
15342
15343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15345 if (SWIG_arg_fail(1)) SWIG_fail;
15346 {
15347 PyThreadState* __tstate = wxPyBeginAllowThreads();
15348 result = (wxEvent *)(arg1)->Clone();
15349
15350 wxPyEndAllowThreads(__tstate);
15351 if (PyErr_Occurred()) SWIG_fail;
15352 }
15353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15354 return resultobj;
15355 fail:
15356 return NULL;
15357 }
15358
15359
15360 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15361 PyObject *obj;
15362 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15363 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15364 Py_INCREF(obj);
15365 return Py_BuildValue((char *)"");
15366 }
15367 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15368 PyObject *resultobj;
15369 wxEvent *arg1 = 0 ;
15370 wxPropagationDisabler *result;
15371 PyObject * obj0 = 0 ;
15372 char *kwnames[] = {
15373 (char *) "event", NULL
15374 };
15375
15376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15377 {
15378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15379 if (SWIG_arg_fail(1)) SWIG_fail;
15380 if (arg1 == NULL) {
15381 SWIG_null_ref("wxEvent");
15382 }
15383 if (SWIG_arg_fail(1)) SWIG_fail;
15384 }
15385 {
15386 PyThreadState* __tstate = wxPyBeginAllowThreads();
15387 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15388
15389 wxPyEndAllowThreads(__tstate);
15390 if (PyErr_Occurred()) SWIG_fail;
15391 }
15392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15400 PyObject *resultobj;
15401 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15402 PyObject * obj0 = 0 ;
15403 char *kwnames[] = {
15404 (char *) "self", NULL
15405 };
15406
15407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15409 if (SWIG_arg_fail(1)) SWIG_fail;
15410 {
15411 PyThreadState* __tstate = wxPyBeginAllowThreads();
15412 delete arg1;
15413
15414 wxPyEndAllowThreads(__tstate);
15415 if (PyErr_Occurred()) SWIG_fail;
15416 }
15417 Py_INCREF(Py_None); resultobj = Py_None;
15418 return resultobj;
15419 fail:
15420 return NULL;
15421 }
15422
15423
15424 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15425 PyObject *obj;
15426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15427 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15428 Py_INCREF(obj);
15429 return Py_BuildValue((char *)"");
15430 }
15431 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15432 PyObject *resultobj;
15433 wxEvent *arg1 = 0 ;
15434 wxPropagateOnce *result;
15435 PyObject * obj0 = 0 ;
15436 char *kwnames[] = {
15437 (char *) "event", NULL
15438 };
15439
15440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15441 {
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 if (arg1 == NULL) {
15445 SWIG_null_ref("wxEvent");
15446 }
15447 if (SWIG_arg_fail(1)) SWIG_fail;
15448 }
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15452
15453 wxPyEndAllowThreads(__tstate);
15454 if (PyErr_Occurred()) SWIG_fail;
15455 }
15456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15457 return resultobj;
15458 fail:
15459 return NULL;
15460 }
15461
15462
15463 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15464 PyObject *resultobj;
15465 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15466 PyObject * obj0 = 0 ;
15467 char *kwnames[] = {
15468 (char *) "self", NULL
15469 };
15470
15471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15473 if (SWIG_arg_fail(1)) SWIG_fail;
15474 {
15475 PyThreadState* __tstate = wxPyBeginAllowThreads();
15476 delete arg1;
15477
15478 wxPyEndAllowThreads(__tstate);
15479 if (PyErr_Occurred()) SWIG_fail;
15480 }
15481 Py_INCREF(Py_None); resultobj = Py_None;
15482 return resultobj;
15483 fail:
15484 return NULL;
15485 }
15486
15487
15488 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15489 PyObject *obj;
15490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15491 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15492 Py_INCREF(obj);
15493 return Py_BuildValue((char *)"");
15494 }
15495 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15496 PyObject *resultobj;
15497 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15498 int arg2 = (int) 0 ;
15499 wxCommandEvent *result;
15500 PyObject * obj0 = 0 ;
15501 PyObject * obj1 = 0 ;
15502 char *kwnames[] = {
15503 (char *) "commandType",(char *) "winid", NULL
15504 };
15505
15506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15507 if (obj0) {
15508 {
15509 arg1 = (wxEventType)(SWIG_As_int(obj0));
15510 if (SWIG_arg_fail(1)) SWIG_fail;
15511 }
15512 }
15513 if (obj1) {
15514 {
15515 arg2 = (int)(SWIG_As_int(obj1));
15516 if (SWIG_arg_fail(2)) SWIG_fail;
15517 }
15518 }
15519 {
15520 PyThreadState* __tstate = wxPyBeginAllowThreads();
15521 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15522
15523 wxPyEndAllowThreads(__tstate);
15524 if (PyErr_Occurred()) SWIG_fail;
15525 }
15526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15527 return resultobj;
15528 fail:
15529 return NULL;
15530 }
15531
15532
15533 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15534 PyObject *resultobj;
15535 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15536 int result;
15537 PyObject * obj0 = 0 ;
15538 char *kwnames[] = {
15539 (char *) "self", NULL
15540 };
15541
15542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15544 if (SWIG_arg_fail(1)) SWIG_fail;
15545 {
15546 PyThreadState* __tstate = wxPyBeginAllowThreads();
15547 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15548
15549 wxPyEndAllowThreads(__tstate);
15550 if (PyErr_Occurred()) SWIG_fail;
15551 }
15552 {
15553 resultobj = SWIG_From_int((int)(result));
15554 }
15555 return resultobj;
15556 fail:
15557 return NULL;
15558 }
15559
15560
15561 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15562 PyObject *resultobj;
15563 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15564 wxString *arg2 = 0 ;
15565 bool temp2 = false ;
15566 PyObject * obj0 = 0 ;
15567 PyObject * obj1 = 0 ;
15568 char *kwnames[] = {
15569 (char *) "self",(char *) "s", NULL
15570 };
15571
15572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15574 if (SWIG_arg_fail(1)) SWIG_fail;
15575 {
15576 arg2 = wxString_in_helper(obj1);
15577 if (arg2 == NULL) SWIG_fail;
15578 temp2 = true;
15579 }
15580 {
15581 PyThreadState* __tstate = wxPyBeginAllowThreads();
15582 (arg1)->SetString((wxString const &)*arg2);
15583
15584 wxPyEndAllowThreads(__tstate);
15585 if (PyErr_Occurred()) SWIG_fail;
15586 }
15587 Py_INCREF(Py_None); resultobj = Py_None;
15588 {
15589 if (temp2)
15590 delete arg2;
15591 }
15592 return resultobj;
15593 fail:
15594 {
15595 if (temp2)
15596 delete arg2;
15597 }
15598 return NULL;
15599 }
15600
15601
15602 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15603 PyObject *resultobj;
15604 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15605 wxString result;
15606 PyObject * obj0 = 0 ;
15607 char *kwnames[] = {
15608 (char *) "self", NULL
15609 };
15610
15611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15613 if (SWIG_arg_fail(1)) SWIG_fail;
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 result = ((wxCommandEvent const *)arg1)->GetString();
15617
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 {
15622 #if wxUSE_UNICODE
15623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15624 #else
15625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15626 #endif
15627 }
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15635 PyObject *resultobj;
15636 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15637 bool result;
15638 PyObject * obj0 = 0 ;
15639 char *kwnames[] = {
15640 (char *) "self", NULL
15641 };
15642
15643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15645 if (SWIG_arg_fail(1)) SWIG_fail;
15646 {
15647 PyThreadState* __tstate = wxPyBeginAllowThreads();
15648 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15649
15650 wxPyEndAllowThreads(__tstate);
15651 if (PyErr_Occurred()) SWIG_fail;
15652 }
15653 {
15654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15655 }
15656 return resultobj;
15657 fail:
15658 return NULL;
15659 }
15660
15661
15662 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15663 PyObject *resultobj;
15664 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15665 bool result;
15666 PyObject * obj0 = 0 ;
15667 char *kwnames[] = {
15668 (char *) "self", NULL
15669 };
15670
15671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15673 if (SWIG_arg_fail(1)) SWIG_fail;
15674 {
15675 PyThreadState* __tstate = wxPyBeginAllowThreads();
15676 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15677
15678 wxPyEndAllowThreads(__tstate);
15679 if (PyErr_Occurred()) SWIG_fail;
15680 }
15681 {
15682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15683 }
15684 return resultobj;
15685 fail:
15686 return NULL;
15687 }
15688
15689
15690 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15691 PyObject *resultobj;
15692 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15693 long arg2 ;
15694 PyObject * obj0 = 0 ;
15695 PyObject * obj1 = 0 ;
15696 char *kwnames[] = {
15697 (char *) "self",(char *) "extraLong", NULL
15698 };
15699
15700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15702 if (SWIG_arg_fail(1)) SWIG_fail;
15703 {
15704 arg2 = (long)(SWIG_As_long(obj1));
15705 if (SWIG_arg_fail(2)) SWIG_fail;
15706 }
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 (arg1)->SetExtraLong(arg2);
15710
15711 wxPyEndAllowThreads(__tstate);
15712 if (PyErr_Occurred()) SWIG_fail;
15713 }
15714 Py_INCREF(Py_None); resultobj = Py_None;
15715 return resultobj;
15716 fail:
15717 return NULL;
15718 }
15719
15720
15721 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15722 PyObject *resultobj;
15723 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15724 long result;
15725 PyObject * obj0 = 0 ;
15726 char *kwnames[] = {
15727 (char *) "self", NULL
15728 };
15729
15730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15732 if (SWIG_arg_fail(1)) SWIG_fail;
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15736
15737 wxPyEndAllowThreads(__tstate);
15738 if (PyErr_Occurred()) SWIG_fail;
15739 }
15740 {
15741 resultobj = SWIG_From_long((long)(result));
15742 }
15743 return resultobj;
15744 fail:
15745 return NULL;
15746 }
15747
15748
15749 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15750 PyObject *resultobj;
15751 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15752 int arg2 ;
15753 PyObject * obj0 = 0 ;
15754 PyObject * obj1 = 0 ;
15755 char *kwnames[] = {
15756 (char *) "self",(char *) "i", NULL
15757 };
15758
15759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15761 if (SWIG_arg_fail(1)) SWIG_fail;
15762 {
15763 arg2 = (int)(SWIG_As_int(obj1));
15764 if (SWIG_arg_fail(2)) SWIG_fail;
15765 }
15766 {
15767 PyThreadState* __tstate = wxPyBeginAllowThreads();
15768 (arg1)->SetInt(arg2);
15769
15770 wxPyEndAllowThreads(__tstate);
15771 if (PyErr_Occurred()) SWIG_fail;
15772 }
15773 Py_INCREF(Py_None); resultobj = Py_None;
15774 return resultobj;
15775 fail:
15776 return NULL;
15777 }
15778
15779
15780 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15781 PyObject *resultobj;
15782 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15783 long result;
15784 PyObject * obj0 = 0 ;
15785 char *kwnames[] = {
15786 (char *) "self", NULL
15787 };
15788
15789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15791 if (SWIG_arg_fail(1)) SWIG_fail;
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15795
15796 wxPyEndAllowThreads(__tstate);
15797 if (PyErr_Occurred()) SWIG_fail;
15798 }
15799 {
15800 resultobj = SWIG_From_long((long)(result));
15801 }
15802 return resultobj;
15803 fail:
15804 return NULL;
15805 }
15806
15807
15808 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15809 PyObject *resultobj;
15810 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15811 wxEvent *result;
15812 PyObject * obj0 = 0 ;
15813 char *kwnames[] = {
15814 (char *) "self", NULL
15815 };
15816
15817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15819 if (SWIG_arg_fail(1)) SWIG_fail;
15820 {
15821 PyThreadState* __tstate = wxPyBeginAllowThreads();
15822 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15823
15824 wxPyEndAllowThreads(__tstate);
15825 if (PyErr_Occurred()) SWIG_fail;
15826 }
15827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15828 return resultobj;
15829 fail:
15830 return NULL;
15831 }
15832
15833
15834 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15835 PyObject *obj;
15836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15837 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15838 Py_INCREF(obj);
15839 return Py_BuildValue((char *)"");
15840 }
15841 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15842 PyObject *resultobj;
15843 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15844 int arg2 = (int) 0 ;
15845 wxNotifyEvent *result;
15846 PyObject * obj0 = 0 ;
15847 PyObject * obj1 = 0 ;
15848 char *kwnames[] = {
15849 (char *) "commandType",(char *) "winid", NULL
15850 };
15851
15852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15853 if (obj0) {
15854 {
15855 arg1 = (wxEventType)(SWIG_As_int(obj0));
15856 if (SWIG_arg_fail(1)) SWIG_fail;
15857 }
15858 }
15859 if (obj1) {
15860 {
15861 arg2 = (int)(SWIG_As_int(obj1));
15862 if (SWIG_arg_fail(2)) SWIG_fail;
15863 }
15864 }
15865 {
15866 PyThreadState* __tstate = wxPyBeginAllowThreads();
15867 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15868
15869 wxPyEndAllowThreads(__tstate);
15870 if (PyErr_Occurred()) SWIG_fail;
15871 }
15872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15873 return resultobj;
15874 fail:
15875 return NULL;
15876 }
15877
15878
15879 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15880 PyObject *resultobj;
15881 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15882 PyObject * obj0 = 0 ;
15883 char *kwnames[] = {
15884 (char *) "self", NULL
15885 };
15886
15887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15889 if (SWIG_arg_fail(1)) SWIG_fail;
15890 {
15891 PyThreadState* __tstate = wxPyBeginAllowThreads();
15892 (arg1)->Veto();
15893
15894 wxPyEndAllowThreads(__tstate);
15895 if (PyErr_Occurred()) SWIG_fail;
15896 }
15897 Py_INCREF(Py_None); resultobj = Py_None;
15898 return resultobj;
15899 fail:
15900 return NULL;
15901 }
15902
15903
15904 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15905 PyObject *resultobj;
15906 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15907 PyObject * obj0 = 0 ;
15908 char *kwnames[] = {
15909 (char *) "self", NULL
15910 };
15911
15912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15914 if (SWIG_arg_fail(1)) SWIG_fail;
15915 {
15916 PyThreadState* __tstate = wxPyBeginAllowThreads();
15917 (arg1)->Allow();
15918
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 Py_INCREF(Py_None); resultobj = Py_None;
15923 return resultobj;
15924 fail:
15925 return NULL;
15926 }
15927
15928
15929 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15930 PyObject *resultobj;
15931 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15932 bool result;
15933 PyObject * obj0 = 0 ;
15934 char *kwnames[] = {
15935 (char *) "self", NULL
15936 };
15937
15938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15940 if (SWIG_arg_fail(1)) SWIG_fail;
15941 {
15942 PyThreadState* __tstate = wxPyBeginAllowThreads();
15943 result = (bool)(arg1)->IsAllowed();
15944
15945 wxPyEndAllowThreads(__tstate);
15946 if (PyErr_Occurred()) SWIG_fail;
15947 }
15948 {
15949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15950 }
15951 return resultobj;
15952 fail:
15953 return NULL;
15954 }
15955
15956
15957 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15958 PyObject *obj;
15959 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15960 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15961 Py_INCREF(obj);
15962 return Py_BuildValue((char *)"");
15963 }
15964 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15965 PyObject *resultobj;
15966 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15967 int arg2 = (int) 0 ;
15968 int arg3 = (int) 0 ;
15969 int arg4 = (int) 0 ;
15970 wxScrollEvent *result;
15971 PyObject * obj0 = 0 ;
15972 PyObject * obj1 = 0 ;
15973 PyObject * obj2 = 0 ;
15974 PyObject * obj3 = 0 ;
15975 char *kwnames[] = {
15976 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15977 };
15978
15979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15980 if (obj0) {
15981 {
15982 arg1 = (wxEventType)(SWIG_As_int(obj0));
15983 if (SWIG_arg_fail(1)) SWIG_fail;
15984 }
15985 }
15986 if (obj1) {
15987 {
15988 arg2 = (int)(SWIG_As_int(obj1));
15989 if (SWIG_arg_fail(2)) SWIG_fail;
15990 }
15991 }
15992 if (obj2) {
15993 {
15994 arg3 = (int)(SWIG_As_int(obj2));
15995 if (SWIG_arg_fail(3)) SWIG_fail;
15996 }
15997 }
15998 if (obj3) {
15999 {
16000 arg4 = (int)(SWIG_As_int(obj3));
16001 if (SWIG_arg_fail(4)) SWIG_fail;
16002 }
16003 }
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16007
16008 wxPyEndAllowThreads(__tstate);
16009 if (PyErr_Occurred()) SWIG_fail;
16010 }
16011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16012 return resultobj;
16013 fail:
16014 return NULL;
16015 }
16016
16017
16018 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16019 PyObject *resultobj;
16020 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16021 int result;
16022 PyObject * obj0 = 0 ;
16023 char *kwnames[] = {
16024 (char *) "self", NULL
16025 };
16026
16027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16029 if (SWIG_arg_fail(1)) SWIG_fail;
16030 {
16031 PyThreadState* __tstate = wxPyBeginAllowThreads();
16032 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16033
16034 wxPyEndAllowThreads(__tstate);
16035 if (PyErr_Occurred()) SWIG_fail;
16036 }
16037 {
16038 resultobj = SWIG_From_int((int)(result));
16039 }
16040 return resultobj;
16041 fail:
16042 return NULL;
16043 }
16044
16045
16046 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16047 PyObject *resultobj;
16048 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16049 int result;
16050 PyObject * obj0 = 0 ;
16051 char *kwnames[] = {
16052 (char *) "self", NULL
16053 };
16054
16055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16057 if (SWIG_arg_fail(1)) SWIG_fail;
16058 {
16059 PyThreadState* __tstate = wxPyBeginAllowThreads();
16060 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16061
16062 wxPyEndAllowThreads(__tstate);
16063 if (PyErr_Occurred()) SWIG_fail;
16064 }
16065 {
16066 resultobj = SWIG_From_int((int)(result));
16067 }
16068 return resultobj;
16069 fail:
16070 return NULL;
16071 }
16072
16073
16074 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16075 PyObject *resultobj;
16076 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16077 int arg2 ;
16078 PyObject * obj0 = 0 ;
16079 PyObject * obj1 = 0 ;
16080 char *kwnames[] = {
16081 (char *) "self",(char *) "orient", NULL
16082 };
16083
16084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16086 if (SWIG_arg_fail(1)) SWIG_fail;
16087 {
16088 arg2 = (int)(SWIG_As_int(obj1));
16089 if (SWIG_arg_fail(2)) SWIG_fail;
16090 }
16091 {
16092 PyThreadState* __tstate = wxPyBeginAllowThreads();
16093 (arg1)->SetOrientation(arg2);
16094
16095 wxPyEndAllowThreads(__tstate);
16096 if (PyErr_Occurred()) SWIG_fail;
16097 }
16098 Py_INCREF(Py_None); resultobj = Py_None;
16099 return resultobj;
16100 fail:
16101 return NULL;
16102 }
16103
16104
16105 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16106 PyObject *resultobj;
16107 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16108 int arg2 ;
16109 PyObject * obj0 = 0 ;
16110 PyObject * obj1 = 0 ;
16111 char *kwnames[] = {
16112 (char *) "self",(char *) "pos", NULL
16113 };
16114
16115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16117 if (SWIG_arg_fail(1)) SWIG_fail;
16118 {
16119 arg2 = (int)(SWIG_As_int(obj1));
16120 if (SWIG_arg_fail(2)) SWIG_fail;
16121 }
16122 {
16123 PyThreadState* __tstate = wxPyBeginAllowThreads();
16124 (arg1)->SetPosition(arg2);
16125
16126 wxPyEndAllowThreads(__tstate);
16127 if (PyErr_Occurred()) SWIG_fail;
16128 }
16129 Py_INCREF(Py_None); resultobj = Py_None;
16130 return resultobj;
16131 fail:
16132 return NULL;
16133 }
16134
16135
16136 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16137 PyObject *obj;
16138 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16139 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16140 Py_INCREF(obj);
16141 return Py_BuildValue((char *)"");
16142 }
16143 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16144 PyObject *resultobj;
16145 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16146 int arg2 = (int) 0 ;
16147 int arg3 = (int) 0 ;
16148 wxScrollWinEvent *result;
16149 PyObject * obj0 = 0 ;
16150 PyObject * obj1 = 0 ;
16151 PyObject * obj2 = 0 ;
16152 char *kwnames[] = {
16153 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16154 };
16155
16156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16157 if (obj0) {
16158 {
16159 arg1 = (wxEventType)(SWIG_As_int(obj0));
16160 if (SWIG_arg_fail(1)) SWIG_fail;
16161 }
16162 }
16163 if (obj1) {
16164 {
16165 arg2 = (int)(SWIG_As_int(obj1));
16166 if (SWIG_arg_fail(2)) SWIG_fail;
16167 }
16168 }
16169 if (obj2) {
16170 {
16171 arg3 = (int)(SWIG_As_int(obj2));
16172 if (SWIG_arg_fail(3)) SWIG_fail;
16173 }
16174 }
16175 {
16176 PyThreadState* __tstate = wxPyBeginAllowThreads();
16177 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16178
16179 wxPyEndAllowThreads(__tstate);
16180 if (PyErr_Occurred()) SWIG_fail;
16181 }
16182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16183 return resultobj;
16184 fail:
16185 return NULL;
16186 }
16187
16188
16189 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16190 PyObject *resultobj;
16191 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16192 int result;
16193 PyObject * obj0 = 0 ;
16194 char *kwnames[] = {
16195 (char *) "self", NULL
16196 };
16197
16198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16200 if (SWIG_arg_fail(1)) SWIG_fail;
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16204
16205 wxPyEndAllowThreads(__tstate);
16206 if (PyErr_Occurred()) SWIG_fail;
16207 }
16208 {
16209 resultobj = SWIG_From_int((int)(result));
16210 }
16211 return resultobj;
16212 fail:
16213 return NULL;
16214 }
16215
16216
16217 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16218 PyObject *resultobj;
16219 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16220 int result;
16221 PyObject * obj0 = 0 ;
16222 char *kwnames[] = {
16223 (char *) "self", NULL
16224 };
16225
16226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16228 if (SWIG_arg_fail(1)) SWIG_fail;
16229 {
16230 PyThreadState* __tstate = wxPyBeginAllowThreads();
16231 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16232
16233 wxPyEndAllowThreads(__tstate);
16234 if (PyErr_Occurred()) SWIG_fail;
16235 }
16236 {
16237 resultobj = SWIG_From_int((int)(result));
16238 }
16239 return resultobj;
16240 fail:
16241 return NULL;
16242 }
16243
16244
16245 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16246 PyObject *resultobj;
16247 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16248 int arg2 ;
16249 PyObject * obj0 = 0 ;
16250 PyObject * obj1 = 0 ;
16251 char *kwnames[] = {
16252 (char *) "self",(char *) "orient", NULL
16253 };
16254
16255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16257 if (SWIG_arg_fail(1)) SWIG_fail;
16258 {
16259 arg2 = (int)(SWIG_As_int(obj1));
16260 if (SWIG_arg_fail(2)) SWIG_fail;
16261 }
16262 {
16263 PyThreadState* __tstate = wxPyBeginAllowThreads();
16264 (arg1)->SetOrientation(arg2);
16265
16266 wxPyEndAllowThreads(__tstate);
16267 if (PyErr_Occurred()) SWIG_fail;
16268 }
16269 Py_INCREF(Py_None); resultobj = Py_None;
16270 return resultobj;
16271 fail:
16272 return NULL;
16273 }
16274
16275
16276 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16277 PyObject *resultobj;
16278 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16279 int arg2 ;
16280 PyObject * obj0 = 0 ;
16281 PyObject * obj1 = 0 ;
16282 char *kwnames[] = {
16283 (char *) "self",(char *) "pos", NULL
16284 };
16285
16286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16288 if (SWIG_arg_fail(1)) SWIG_fail;
16289 {
16290 arg2 = (int)(SWIG_As_int(obj1));
16291 if (SWIG_arg_fail(2)) SWIG_fail;
16292 }
16293 {
16294 PyThreadState* __tstate = wxPyBeginAllowThreads();
16295 (arg1)->SetPosition(arg2);
16296
16297 wxPyEndAllowThreads(__tstate);
16298 if (PyErr_Occurred()) SWIG_fail;
16299 }
16300 Py_INCREF(Py_None); resultobj = Py_None;
16301 return resultobj;
16302 fail:
16303 return NULL;
16304 }
16305
16306
16307 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16308 PyObject *obj;
16309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16310 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16311 Py_INCREF(obj);
16312 return Py_BuildValue((char *)"");
16313 }
16314 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16315 PyObject *resultobj;
16316 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16317 wxMouseEvent *result;
16318 PyObject * obj0 = 0 ;
16319 char *kwnames[] = {
16320 (char *) "mouseType", NULL
16321 };
16322
16323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16324 if (obj0) {
16325 {
16326 arg1 = (wxEventType)(SWIG_As_int(obj0));
16327 if (SWIG_arg_fail(1)) SWIG_fail;
16328 }
16329 }
16330 {
16331 PyThreadState* __tstate = wxPyBeginAllowThreads();
16332 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16333
16334 wxPyEndAllowThreads(__tstate);
16335 if (PyErr_Occurred()) SWIG_fail;
16336 }
16337 {
16338 resultobj = wxPyMake_wxObject(result, 1);
16339 }
16340 return resultobj;
16341 fail:
16342 return NULL;
16343 }
16344
16345
16346 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16347 PyObject *resultobj;
16348 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16349 bool result;
16350 PyObject * obj0 = 0 ;
16351 char *kwnames[] = {
16352 (char *) "self", NULL
16353 };
16354
16355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16357 if (SWIG_arg_fail(1)) SWIG_fail;
16358 {
16359 PyThreadState* __tstate = wxPyBeginAllowThreads();
16360 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16361
16362 wxPyEndAllowThreads(__tstate);
16363 if (PyErr_Occurred()) SWIG_fail;
16364 }
16365 {
16366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16367 }
16368 return resultobj;
16369 fail:
16370 return NULL;
16371 }
16372
16373
16374 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16375 PyObject *resultobj;
16376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16377 int arg2 = (int) wxMOUSE_BTN_ANY ;
16378 bool result;
16379 PyObject * obj0 = 0 ;
16380 PyObject * obj1 = 0 ;
16381 char *kwnames[] = {
16382 (char *) "self",(char *) "but", NULL
16383 };
16384
16385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16387 if (SWIG_arg_fail(1)) SWIG_fail;
16388 if (obj1) {
16389 {
16390 arg2 = (int)(SWIG_As_int(obj1));
16391 if (SWIG_arg_fail(2)) SWIG_fail;
16392 }
16393 }
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16397
16398 wxPyEndAllowThreads(__tstate);
16399 if (PyErr_Occurred()) SWIG_fail;
16400 }
16401 {
16402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16403 }
16404 return resultobj;
16405 fail:
16406 return NULL;
16407 }
16408
16409
16410 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16411 PyObject *resultobj;
16412 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16413 int arg2 = (int) wxMOUSE_BTN_ANY ;
16414 bool result;
16415 PyObject * obj0 = 0 ;
16416 PyObject * obj1 = 0 ;
16417 char *kwnames[] = {
16418 (char *) "self",(char *) "but", NULL
16419 };
16420
16421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16423 if (SWIG_arg_fail(1)) SWIG_fail;
16424 if (obj1) {
16425 {
16426 arg2 = (int)(SWIG_As_int(obj1));
16427 if (SWIG_arg_fail(2)) SWIG_fail;
16428 }
16429 }
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16433
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 {
16438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16439 }
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj;
16448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16449 int arg2 = (int) wxMOUSE_BTN_ANY ;
16450 bool result;
16451 PyObject * obj0 = 0 ;
16452 PyObject * obj1 = 0 ;
16453 char *kwnames[] = {
16454 (char *) "self",(char *) "but", NULL
16455 };
16456
16457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16459 if (SWIG_arg_fail(1)) SWIG_fail;
16460 if (obj1) {
16461 {
16462 arg2 = (int)(SWIG_As_int(obj1));
16463 if (SWIG_arg_fail(2)) SWIG_fail;
16464 }
16465 }
16466 {
16467 PyThreadState* __tstate = wxPyBeginAllowThreads();
16468 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16469
16470 wxPyEndAllowThreads(__tstate);
16471 if (PyErr_Occurred()) SWIG_fail;
16472 }
16473 {
16474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16475 }
16476 return resultobj;
16477 fail:
16478 return NULL;
16479 }
16480
16481
16482 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16483 PyObject *resultobj;
16484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16485 int arg2 ;
16486 bool result;
16487 PyObject * obj0 = 0 ;
16488 PyObject * obj1 = 0 ;
16489 char *kwnames[] = {
16490 (char *) "self",(char *) "but", NULL
16491 };
16492
16493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16495 if (SWIG_arg_fail(1)) SWIG_fail;
16496 {
16497 arg2 = (int)(SWIG_As_int(obj1));
16498 if (SWIG_arg_fail(2)) SWIG_fail;
16499 }
16500 {
16501 PyThreadState* __tstate = wxPyBeginAllowThreads();
16502 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16503
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 {
16508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16509 }
16510 return resultobj;
16511 fail:
16512 return NULL;
16513 }
16514
16515
16516 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16517 PyObject *resultobj;
16518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16519 int arg2 ;
16520 bool result;
16521 PyObject * obj0 = 0 ;
16522 PyObject * obj1 = 0 ;
16523 char *kwnames[] = {
16524 (char *) "self",(char *) "but", NULL
16525 };
16526
16527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16529 if (SWIG_arg_fail(1)) SWIG_fail;
16530 {
16531 arg2 = (int)(SWIG_As_int(obj1));
16532 if (SWIG_arg_fail(2)) SWIG_fail;
16533 }
16534 {
16535 PyThreadState* __tstate = wxPyBeginAllowThreads();
16536 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16537
16538 wxPyEndAllowThreads(__tstate);
16539 if (PyErr_Occurred()) SWIG_fail;
16540 }
16541 {
16542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16543 }
16544 return resultobj;
16545 fail:
16546 return NULL;
16547 }
16548
16549
16550 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16551 PyObject *resultobj;
16552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16553 int result;
16554 PyObject * obj0 = 0 ;
16555 char *kwnames[] = {
16556 (char *) "self", NULL
16557 };
16558
16559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16561 if (SWIG_arg_fail(1)) SWIG_fail;
16562 {
16563 PyThreadState* __tstate = wxPyBeginAllowThreads();
16564 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16565
16566 wxPyEndAllowThreads(__tstate);
16567 if (PyErr_Occurred()) SWIG_fail;
16568 }
16569 {
16570 resultobj = SWIG_From_int((int)(result));
16571 }
16572 return resultobj;
16573 fail:
16574 return NULL;
16575 }
16576
16577
16578 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16579 PyObject *resultobj;
16580 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16581 bool result;
16582 PyObject * obj0 = 0 ;
16583 char *kwnames[] = {
16584 (char *) "self", NULL
16585 };
16586
16587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16589 if (SWIG_arg_fail(1)) SWIG_fail;
16590 {
16591 PyThreadState* __tstate = wxPyBeginAllowThreads();
16592 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16593
16594 wxPyEndAllowThreads(__tstate);
16595 if (PyErr_Occurred()) SWIG_fail;
16596 }
16597 {
16598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16599 }
16600 return resultobj;
16601 fail:
16602 return NULL;
16603 }
16604
16605
16606 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16607 PyObject *resultobj;
16608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16609 bool result;
16610 PyObject * obj0 = 0 ;
16611 char *kwnames[] = {
16612 (char *) "self", NULL
16613 };
16614
16615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16617 if (SWIG_arg_fail(1)) SWIG_fail;
16618 {
16619 PyThreadState* __tstate = wxPyBeginAllowThreads();
16620 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16621
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 {
16626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16627 }
16628 return resultobj;
16629 fail:
16630 return NULL;
16631 }
16632
16633
16634 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16635 PyObject *resultobj;
16636 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16637 bool result;
16638 PyObject * obj0 = 0 ;
16639 char *kwnames[] = {
16640 (char *) "self", NULL
16641 };
16642
16643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16645 if (SWIG_arg_fail(1)) SWIG_fail;
16646 {
16647 PyThreadState* __tstate = wxPyBeginAllowThreads();
16648 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16649
16650 wxPyEndAllowThreads(__tstate);
16651 if (PyErr_Occurred()) SWIG_fail;
16652 }
16653 {
16654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16655 }
16656 return resultobj;
16657 fail:
16658 return NULL;
16659 }
16660
16661
16662 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16663 PyObject *resultobj;
16664 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16665 bool result;
16666 PyObject * obj0 = 0 ;
16667 char *kwnames[] = {
16668 (char *) "self", NULL
16669 };
16670
16671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16673 if (SWIG_arg_fail(1)) SWIG_fail;
16674 {
16675 PyThreadState* __tstate = wxPyBeginAllowThreads();
16676 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16677
16678 wxPyEndAllowThreads(__tstate);
16679 if (PyErr_Occurred()) SWIG_fail;
16680 }
16681 {
16682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16683 }
16684 return resultobj;
16685 fail:
16686 return NULL;
16687 }
16688
16689
16690 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16691 PyObject *resultobj;
16692 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16693 bool result;
16694 PyObject * obj0 = 0 ;
16695 char *kwnames[] = {
16696 (char *) "self", NULL
16697 };
16698
16699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16701 if (SWIG_arg_fail(1)) SWIG_fail;
16702 {
16703 PyThreadState* __tstate = wxPyBeginAllowThreads();
16704 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16705
16706 wxPyEndAllowThreads(__tstate);
16707 if (PyErr_Occurred()) SWIG_fail;
16708 }
16709 {
16710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16711 }
16712 return resultobj;
16713 fail:
16714 return NULL;
16715 }
16716
16717
16718 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16719 PyObject *resultobj;
16720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16721 bool result;
16722 PyObject * obj0 = 0 ;
16723 char *kwnames[] = {
16724 (char *) "self", NULL
16725 };
16726
16727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16729 if (SWIG_arg_fail(1)) SWIG_fail;
16730 {
16731 PyThreadState* __tstate = wxPyBeginAllowThreads();
16732 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16733
16734 wxPyEndAllowThreads(__tstate);
16735 if (PyErr_Occurred()) SWIG_fail;
16736 }
16737 {
16738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16739 }
16740 return resultobj;
16741 fail:
16742 return NULL;
16743 }
16744
16745
16746 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16747 PyObject *resultobj;
16748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16749 bool result;
16750 PyObject * obj0 = 0 ;
16751 char *kwnames[] = {
16752 (char *) "self", NULL
16753 };
16754
16755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16757 if (SWIG_arg_fail(1)) SWIG_fail;
16758 {
16759 PyThreadState* __tstate = wxPyBeginAllowThreads();
16760 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16761
16762 wxPyEndAllowThreads(__tstate);
16763 if (PyErr_Occurred()) SWIG_fail;
16764 }
16765 {
16766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16767 }
16768 return resultobj;
16769 fail:
16770 return NULL;
16771 }
16772
16773
16774 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16775 PyObject *resultobj;
16776 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16777 bool result;
16778 PyObject * obj0 = 0 ;
16779 char *kwnames[] = {
16780 (char *) "self", NULL
16781 };
16782
16783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16785 if (SWIG_arg_fail(1)) SWIG_fail;
16786 {
16787 PyThreadState* __tstate = wxPyBeginAllowThreads();
16788 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16789
16790 wxPyEndAllowThreads(__tstate);
16791 if (PyErr_Occurred()) SWIG_fail;
16792 }
16793 {
16794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16795 }
16796 return resultobj;
16797 fail:
16798 return NULL;
16799 }
16800
16801
16802 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16803 PyObject *resultobj;
16804 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16805 bool result;
16806 PyObject * obj0 = 0 ;
16807 char *kwnames[] = {
16808 (char *) "self", NULL
16809 };
16810
16811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16813 if (SWIG_arg_fail(1)) SWIG_fail;
16814 {
16815 PyThreadState* __tstate = wxPyBeginAllowThreads();
16816 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16817
16818 wxPyEndAllowThreads(__tstate);
16819 if (PyErr_Occurred()) SWIG_fail;
16820 }
16821 {
16822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16823 }
16824 return resultobj;
16825 fail:
16826 return NULL;
16827 }
16828
16829
16830 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16831 PyObject *resultobj;
16832 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16833 bool result;
16834 PyObject * obj0 = 0 ;
16835 char *kwnames[] = {
16836 (char *) "self", NULL
16837 };
16838
16839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16841 if (SWIG_arg_fail(1)) SWIG_fail;
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16845
16846 wxPyEndAllowThreads(__tstate);
16847 if (PyErr_Occurred()) SWIG_fail;
16848 }
16849 {
16850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16851 }
16852 return resultobj;
16853 fail:
16854 return NULL;
16855 }
16856
16857
16858 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16859 PyObject *resultobj;
16860 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16861 bool result;
16862 PyObject * obj0 = 0 ;
16863 char *kwnames[] = {
16864 (char *) "self", NULL
16865 };
16866
16867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16869 if (SWIG_arg_fail(1)) SWIG_fail;
16870 {
16871 PyThreadState* __tstate = wxPyBeginAllowThreads();
16872 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16873
16874 wxPyEndAllowThreads(__tstate);
16875 if (PyErr_Occurred()) SWIG_fail;
16876 }
16877 {
16878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16879 }
16880 return resultobj;
16881 fail:
16882 return NULL;
16883 }
16884
16885
16886 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16887 PyObject *resultobj;
16888 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16889 bool result;
16890 PyObject * obj0 = 0 ;
16891 char *kwnames[] = {
16892 (char *) "self", NULL
16893 };
16894
16895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16897 if (SWIG_arg_fail(1)) SWIG_fail;
16898 {
16899 PyThreadState* __tstate = wxPyBeginAllowThreads();
16900 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16901
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 {
16906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16907 }
16908 return resultobj;
16909 fail:
16910 return NULL;
16911 }
16912
16913
16914 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16915 PyObject *resultobj;
16916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16917 bool result;
16918 PyObject * obj0 = 0 ;
16919 char *kwnames[] = {
16920 (char *) "self", NULL
16921 };
16922
16923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16925 if (SWIG_arg_fail(1)) SWIG_fail;
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16929
16930 wxPyEndAllowThreads(__tstate);
16931 if (PyErr_Occurred()) SWIG_fail;
16932 }
16933 {
16934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16935 }
16936 return resultobj;
16937 fail:
16938 return NULL;
16939 }
16940
16941
16942 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16943 PyObject *resultobj;
16944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16945 bool result;
16946 PyObject * obj0 = 0 ;
16947 char *kwnames[] = {
16948 (char *) "self", NULL
16949 };
16950
16951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16953 if (SWIG_arg_fail(1)) SWIG_fail;
16954 {
16955 PyThreadState* __tstate = wxPyBeginAllowThreads();
16956 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16957
16958 wxPyEndAllowThreads(__tstate);
16959 if (PyErr_Occurred()) SWIG_fail;
16960 }
16961 {
16962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16963 }
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16971 PyObject *resultobj;
16972 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16973 bool result;
16974 PyObject * obj0 = 0 ;
16975 char *kwnames[] = {
16976 (char *) "self", NULL
16977 };
16978
16979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16981 if (SWIG_arg_fail(1)) SWIG_fail;
16982 {
16983 PyThreadState* __tstate = wxPyBeginAllowThreads();
16984 result = (bool)(arg1)->LeftIsDown();
16985
16986 wxPyEndAllowThreads(__tstate);
16987 if (PyErr_Occurred()) SWIG_fail;
16988 }
16989 {
16990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16991 }
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16999 PyObject *resultobj;
17000 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17001 bool result;
17002 PyObject * obj0 = 0 ;
17003 char *kwnames[] = {
17004 (char *) "self", NULL
17005 };
17006
17007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17009 if (SWIG_arg_fail(1)) SWIG_fail;
17010 {
17011 PyThreadState* __tstate = wxPyBeginAllowThreads();
17012 result = (bool)(arg1)->MiddleIsDown();
17013
17014 wxPyEndAllowThreads(__tstate);
17015 if (PyErr_Occurred()) SWIG_fail;
17016 }
17017 {
17018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17019 }
17020 return resultobj;
17021 fail:
17022 return NULL;
17023 }
17024
17025
17026 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17027 PyObject *resultobj;
17028 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17029 bool result;
17030 PyObject * obj0 = 0 ;
17031 char *kwnames[] = {
17032 (char *) "self", NULL
17033 };
17034
17035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17037 if (SWIG_arg_fail(1)) SWIG_fail;
17038 {
17039 PyThreadState* __tstate = wxPyBeginAllowThreads();
17040 result = (bool)(arg1)->RightIsDown();
17041
17042 wxPyEndAllowThreads(__tstate);
17043 if (PyErr_Occurred()) SWIG_fail;
17044 }
17045 {
17046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17047 }
17048 return resultobj;
17049 fail:
17050 return NULL;
17051 }
17052
17053
17054 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17055 PyObject *resultobj;
17056 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17057 bool result;
17058 PyObject * obj0 = 0 ;
17059 char *kwnames[] = {
17060 (char *) "self", NULL
17061 };
17062
17063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17065 if (SWIG_arg_fail(1)) SWIG_fail;
17066 {
17067 PyThreadState* __tstate = wxPyBeginAllowThreads();
17068 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17069
17070 wxPyEndAllowThreads(__tstate);
17071 if (PyErr_Occurred()) SWIG_fail;
17072 }
17073 {
17074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17075 }
17076 return resultobj;
17077 fail:
17078 return NULL;
17079 }
17080
17081
17082 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17083 PyObject *resultobj;
17084 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17085 bool result;
17086 PyObject * obj0 = 0 ;
17087 char *kwnames[] = {
17088 (char *) "self", NULL
17089 };
17090
17091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17093 if (SWIG_arg_fail(1)) SWIG_fail;
17094 {
17095 PyThreadState* __tstate = wxPyBeginAllowThreads();
17096 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17097
17098 wxPyEndAllowThreads(__tstate);
17099 if (PyErr_Occurred()) SWIG_fail;
17100 }
17101 {
17102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17103 }
17104 return resultobj;
17105 fail:
17106 return NULL;
17107 }
17108
17109
17110 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17111 PyObject *resultobj;
17112 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17113 bool result;
17114 PyObject * obj0 = 0 ;
17115 char *kwnames[] = {
17116 (char *) "self", NULL
17117 };
17118
17119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17121 if (SWIG_arg_fail(1)) SWIG_fail;
17122 {
17123 PyThreadState* __tstate = wxPyBeginAllowThreads();
17124 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17125
17126 wxPyEndAllowThreads(__tstate);
17127 if (PyErr_Occurred()) SWIG_fail;
17128 }
17129 {
17130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17131 }
17132 return resultobj;
17133 fail:
17134 return NULL;
17135 }
17136
17137
17138 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17139 PyObject *resultobj;
17140 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17141 bool result;
17142 PyObject * obj0 = 0 ;
17143 char *kwnames[] = {
17144 (char *) "self", NULL
17145 };
17146
17147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17149 if (SWIG_arg_fail(1)) SWIG_fail;
17150 {
17151 PyThreadState* __tstate = wxPyBeginAllowThreads();
17152 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17153
17154 wxPyEndAllowThreads(__tstate);
17155 if (PyErr_Occurred()) SWIG_fail;
17156 }
17157 {
17158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17159 }
17160 return resultobj;
17161 fail:
17162 return NULL;
17163 }
17164
17165
17166 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17167 PyObject *resultobj;
17168 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17169 wxPoint result;
17170 PyObject * obj0 = 0 ;
17171 char *kwnames[] = {
17172 (char *) "self", NULL
17173 };
17174
17175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17177 if (SWIG_arg_fail(1)) SWIG_fail;
17178 {
17179 PyThreadState* __tstate = wxPyBeginAllowThreads();
17180 result = (arg1)->GetPosition();
17181
17182 wxPyEndAllowThreads(__tstate);
17183 if (PyErr_Occurred()) SWIG_fail;
17184 }
17185 {
17186 wxPoint * resultptr;
17187 resultptr = new wxPoint((wxPoint &)(result));
17188 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17189 }
17190 return resultobj;
17191 fail:
17192 return NULL;
17193 }
17194
17195
17196 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17197 PyObject *resultobj;
17198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17199 long *arg2 = (long *) 0 ;
17200 long *arg3 = (long *) 0 ;
17201 long temp2 ;
17202 int res2 = 0 ;
17203 long temp3 ;
17204 int res3 = 0 ;
17205 PyObject * obj0 = 0 ;
17206 char *kwnames[] = {
17207 (char *) "self", NULL
17208 };
17209
17210 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17211 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17214 if (SWIG_arg_fail(1)) SWIG_fail;
17215 {
17216 PyThreadState* __tstate = wxPyBeginAllowThreads();
17217 (arg1)->GetPosition(arg2,arg3);
17218
17219 wxPyEndAllowThreads(__tstate);
17220 if (PyErr_Occurred()) SWIG_fail;
17221 }
17222 Py_INCREF(Py_None); resultobj = Py_None;
17223 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17224 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17225 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17226 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17227 return resultobj;
17228 fail:
17229 return NULL;
17230 }
17231
17232
17233 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17234 PyObject *resultobj;
17235 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17236 wxDC *arg2 = 0 ;
17237 wxPoint result;
17238 PyObject * obj0 = 0 ;
17239 PyObject * obj1 = 0 ;
17240 char *kwnames[] = {
17241 (char *) "self",(char *) "dc", NULL
17242 };
17243
17244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17246 if (SWIG_arg_fail(1)) SWIG_fail;
17247 {
17248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17249 if (SWIG_arg_fail(2)) SWIG_fail;
17250 if (arg2 == NULL) {
17251 SWIG_null_ref("wxDC");
17252 }
17253 if (SWIG_arg_fail(2)) SWIG_fail;
17254 }
17255 {
17256 PyThreadState* __tstate = wxPyBeginAllowThreads();
17257 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17258
17259 wxPyEndAllowThreads(__tstate);
17260 if (PyErr_Occurred()) SWIG_fail;
17261 }
17262 {
17263 wxPoint * resultptr;
17264 resultptr = new wxPoint((wxPoint &)(result));
17265 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17266 }
17267 return resultobj;
17268 fail:
17269 return NULL;
17270 }
17271
17272
17273 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17274 PyObject *resultobj;
17275 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17276 int result;
17277 PyObject * obj0 = 0 ;
17278 char *kwnames[] = {
17279 (char *) "self", NULL
17280 };
17281
17282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17284 if (SWIG_arg_fail(1)) SWIG_fail;
17285 {
17286 PyThreadState* __tstate = wxPyBeginAllowThreads();
17287 result = (int)((wxMouseEvent const *)arg1)->GetX();
17288
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 {
17293 resultobj = SWIG_From_int((int)(result));
17294 }
17295 return resultobj;
17296 fail:
17297 return NULL;
17298 }
17299
17300
17301 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17302 PyObject *resultobj;
17303 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17304 int result;
17305 PyObject * obj0 = 0 ;
17306 char *kwnames[] = {
17307 (char *) "self", NULL
17308 };
17309
17310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17312 if (SWIG_arg_fail(1)) SWIG_fail;
17313 {
17314 PyThreadState* __tstate = wxPyBeginAllowThreads();
17315 result = (int)((wxMouseEvent const *)arg1)->GetY();
17316
17317 wxPyEndAllowThreads(__tstate);
17318 if (PyErr_Occurred()) SWIG_fail;
17319 }
17320 {
17321 resultobj = SWIG_From_int((int)(result));
17322 }
17323 return resultobj;
17324 fail:
17325 return NULL;
17326 }
17327
17328
17329 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17330 PyObject *resultobj;
17331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17332 int result;
17333 PyObject * obj0 = 0 ;
17334 char *kwnames[] = {
17335 (char *) "self", NULL
17336 };
17337
17338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17340 if (SWIG_arg_fail(1)) SWIG_fail;
17341 {
17342 PyThreadState* __tstate = wxPyBeginAllowThreads();
17343 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17344
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 {
17349 resultobj = SWIG_From_int((int)(result));
17350 }
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj;
17359 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17360 int result;
17361 PyObject * obj0 = 0 ;
17362 char *kwnames[] = {
17363 (char *) "self", NULL
17364 };
17365
17366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17368 if (SWIG_arg_fail(1)) SWIG_fail;
17369 {
17370 PyThreadState* __tstate = wxPyBeginAllowThreads();
17371 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17372
17373 wxPyEndAllowThreads(__tstate);
17374 if (PyErr_Occurred()) SWIG_fail;
17375 }
17376 {
17377 resultobj = SWIG_From_int((int)(result));
17378 }
17379 return resultobj;
17380 fail:
17381 return NULL;
17382 }
17383
17384
17385 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17386 PyObject *resultobj;
17387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17388 int result;
17389 PyObject * obj0 = 0 ;
17390 char *kwnames[] = {
17391 (char *) "self", NULL
17392 };
17393
17394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17396 if (SWIG_arg_fail(1)) SWIG_fail;
17397 {
17398 PyThreadState* __tstate = wxPyBeginAllowThreads();
17399 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17400
17401 wxPyEndAllowThreads(__tstate);
17402 if (PyErr_Occurred()) SWIG_fail;
17403 }
17404 {
17405 resultobj = SWIG_From_int((int)(result));
17406 }
17407 return resultobj;
17408 fail:
17409 return NULL;
17410 }
17411
17412
17413 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17414 PyObject *resultobj;
17415 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17416 bool result;
17417 PyObject * obj0 = 0 ;
17418 char *kwnames[] = {
17419 (char *) "self", NULL
17420 };
17421
17422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17424 if (SWIG_arg_fail(1)) SWIG_fail;
17425 {
17426 PyThreadState* __tstate = wxPyBeginAllowThreads();
17427 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17428
17429 wxPyEndAllowThreads(__tstate);
17430 if (PyErr_Occurred()) SWIG_fail;
17431 }
17432 {
17433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17434 }
17435 return resultobj;
17436 fail:
17437 return NULL;
17438 }
17439
17440
17441 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17442 PyObject *resultobj;
17443 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17444 int arg2 ;
17445 PyObject * obj0 = 0 ;
17446 PyObject * obj1 = 0 ;
17447 char *kwnames[] = {
17448 (char *) "self",(char *) "m_x", NULL
17449 };
17450
17451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17453 if (SWIG_arg_fail(1)) SWIG_fail;
17454 {
17455 arg2 = (int)(SWIG_As_int(obj1));
17456 if (SWIG_arg_fail(2)) SWIG_fail;
17457 }
17458 if (arg1) (arg1)->m_x = arg2;
17459
17460 Py_INCREF(Py_None); resultobj = Py_None;
17461 return resultobj;
17462 fail:
17463 return NULL;
17464 }
17465
17466
17467 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17468 PyObject *resultobj;
17469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17470 int result;
17471 PyObject * obj0 = 0 ;
17472 char *kwnames[] = {
17473 (char *) "self", NULL
17474 };
17475
17476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) 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 result = (int) ((arg1)->m_x);
17480
17481 {
17482 resultobj = SWIG_From_int((int)(result));
17483 }
17484 return resultobj;
17485 fail:
17486 return NULL;
17487 }
17488
17489
17490 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17491 PyObject *resultobj;
17492 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17493 int arg2 ;
17494 PyObject * obj0 = 0 ;
17495 PyObject * obj1 = 0 ;
17496 char *kwnames[] = {
17497 (char *) "self",(char *) "m_y", NULL
17498 };
17499
17500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17502 if (SWIG_arg_fail(1)) SWIG_fail;
17503 {
17504 arg2 = (int)(SWIG_As_int(obj1));
17505 if (SWIG_arg_fail(2)) SWIG_fail;
17506 }
17507 if (arg1) (arg1)->m_y = arg2;
17508
17509 Py_INCREF(Py_None); resultobj = Py_None;
17510 return resultobj;
17511 fail:
17512 return NULL;
17513 }
17514
17515
17516 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17517 PyObject *resultobj;
17518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17519 int result;
17520 PyObject * obj0 = 0 ;
17521 char *kwnames[] = {
17522 (char *) "self", NULL
17523 };
17524
17525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) 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 result = (int) ((arg1)->m_y);
17529
17530 {
17531 resultobj = SWIG_From_int((int)(result));
17532 }
17533 return resultobj;
17534 fail:
17535 return NULL;
17536 }
17537
17538
17539 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17540 PyObject *resultobj;
17541 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17542 bool arg2 ;
17543 PyObject * obj0 = 0 ;
17544 PyObject * obj1 = 0 ;
17545 char *kwnames[] = {
17546 (char *) "self",(char *) "m_leftDown", NULL
17547 };
17548
17549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17551 if (SWIG_arg_fail(1)) SWIG_fail;
17552 {
17553 arg2 = (bool)(SWIG_As_bool(obj1));
17554 if (SWIG_arg_fail(2)) SWIG_fail;
17555 }
17556 if (arg1) (arg1)->m_leftDown = arg2;
17557
17558 Py_INCREF(Py_None); resultobj = Py_None;
17559 return resultobj;
17560 fail:
17561 return NULL;
17562 }
17563
17564
17565 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17566 PyObject *resultobj;
17567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17568 bool result;
17569 PyObject * obj0 = 0 ;
17570 char *kwnames[] = {
17571 (char *) "self", NULL
17572 };
17573
17574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_leftDown);
17578
17579 {
17580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17581 }
17582 return resultobj;
17583 fail:
17584 return NULL;
17585 }
17586
17587
17588 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17589 PyObject *resultobj;
17590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17591 bool arg2 ;
17592 PyObject * obj0 = 0 ;
17593 PyObject * obj1 = 0 ;
17594 char *kwnames[] = {
17595 (char *) "self",(char *) "m_middleDown", NULL
17596 };
17597
17598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17600 if (SWIG_arg_fail(1)) SWIG_fail;
17601 {
17602 arg2 = (bool)(SWIG_As_bool(obj1));
17603 if (SWIG_arg_fail(2)) SWIG_fail;
17604 }
17605 if (arg1) (arg1)->m_middleDown = arg2;
17606
17607 Py_INCREF(Py_None); resultobj = Py_None;
17608 return resultobj;
17609 fail:
17610 return NULL;
17611 }
17612
17613
17614 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17615 PyObject *resultobj;
17616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17617 bool result;
17618 PyObject * obj0 = 0 ;
17619 char *kwnames[] = {
17620 (char *) "self", NULL
17621 };
17622
17623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_middleDown);
17627
17628 {
17629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17630 }
17631 return resultobj;
17632 fail:
17633 return NULL;
17634 }
17635
17636
17637 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17638 PyObject *resultobj;
17639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17640 bool arg2 ;
17641 PyObject * obj0 = 0 ;
17642 PyObject * obj1 = 0 ;
17643 char *kwnames[] = {
17644 (char *) "self",(char *) "m_rightDown", NULL
17645 };
17646
17647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17649 if (SWIG_arg_fail(1)) SWIG_fail;
17650 {
17651 arg2 = (bool)(SWIG_As_bool(obj1));
17652 if (SWIG_arg_fail(2)) SWIG_fail;
17653 }
17654 if (arg1) (arg1)->m_rightDown = arg2;
17655
17656 Py_INCREF(Py_None); resultobj = Py_None;
17657 return resultobj;
17658 fail:
17659 return NULL;
17660 }
17661
17662
17663 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17664 PyObject *resultobj;
17665 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17666 bool result;
17667 PyObject * obj0 = 0 ;
17668 char *kwnames[] = {
17669 (char *) "self", NULL
17670 };
17671
17672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17674 if (SWIG_arg_fail(1)) SWIG_fail;
17675 result = (bool) ((arg1)->m_rightDown);
17676
17677 {
17678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17679 }
17680 return resultobj;
17681 fail:
17682 return NULL;
17683 }
17684
17685
17686 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17687 PyObject *resultobj;
17688 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17689 bool arg2 ;
17690 PyObject * obj0 = 0 ;
17691 PyObject * obj1 = 0 ;
17692 char *kwnames[] = {
17693 (char *) "self",(char *) "m_controlDown", NULL
17694 };
17695
17696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17698 if (SWIG_arg_fail(1)) SWIG_fail;
17699 {
17700 arg2 = (bool)(SWIG_As_bool(obj1));
17701 if (SWIG_arg_fail(2)) SWIG_fail;
17702 }
17703 if (arg1) (arg1)->m_controlDown = arg2;
17704
17705 Py_INCREF(Py_None); resultobj = Py_None;
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17713 PyObject *resultobj;
17714 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17715 bool result;
17716 PyObject * obj0 = 0 ;
17717 char *kwnames[] = {
17718 (char *) "self", NULL
17719 };
17720
17721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17723 if (SWIG_arg_fail(1)) SWIG_fail;
17724 result = (bool) ((arg1)->m_controlDown);
17725
17726 {
17727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17728 }
17729 return resultobj;
17730 fail:
17731 return NULL;
17732 }
17733
17734
17735 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17736 PyObject *resultobj;
17737 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17738 bool arg2 ;
17739 PyObject * obj0 = 0 ;
17740 PyObject * obj1 = 0 ;
17741 char *kwnames[] = {
17742 (char *) "self",(char *) "m_shiftDown", NULL
17743 };
17744
17745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17747 if (SWIG_arg_fail(1)) SWIG_fail;
17748 {
17749 arg2 = (bool)(SWIG_As_bool(obj1));
17750 if (SWIG_arg_fail(2)) SWIG_fail;
17751 }
17752 if (arg1) (arg1)->m_shiftDown = arg2;
17753
17754 Py_INCREF(Py_None); resultobj = Py_None;
17755 return resultobj;
17756 fail:
17757 return NULL;
17758 }
17759
17760
17761 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17762 PyObject *resultobj;
17763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17764 bool result;
17765 PyObject * obj0 = 0 ;
17766 char *kwnames[] = {
17767 (char *) "self", NULL
17768 };
17769
17770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17772 if (SWIG_arg_fail(1)) SWIG_fail;
17773 result = (bool) ((arg1)->m_shiftDown);
17774
17775 {
17776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17777 }
17778 return resultobj;
17779 fail:
17780 return NULL;
17781 }
17782
17783
17784 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17785 PyObject *resultobj;
17786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17787 bool arg2 ;
17788 PyObject * obj0 = 0 ;
17789 PyObject * obj1 = 0 ;
17790 char *kwnames[] = {
17791 (char *) "self",(char *) "m_altDown", NULL
17792 };
17793
17794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17796 if (SWIG_arg_fail(1)) SWIG_fail;
17797 {
17798 arg2 = (bool)(SWIG_As_bool(obj1));
17799 if (SWIG_arg_fail(2)) SWIG_fail;
17800 }
17801 if (arg1) (arg1)->m_altDown = arg2;
17802
17803 Py_INCREF(Py_None); resultobj = Py_None;
17804 return resultobj;
17805 fail:
17806 return NULL;
17807 }
17808
17809
17810 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17811 PyObject *resultobj;
17812 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17813 bool result;
17814 PyObject * obj0 = 0 ;
17815 char *kwnames[] = {
17816 (char *) "self", NULL
17817 };
17818
17819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17821 if (SWIG_arg_fail(1)) SWIG_fail;
17822 result = (bool) ((arg1)->m_altDown);
17823
17824 {
17825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17826 }
17827 return resultobj;
17828 fail:
17829 return NULL;
17830 }
17831
17832
17833 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17834 PyObject *resultobj;
17835 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17836 bool arg2 ;
17837 PyObject * obj0 = 0 ;
17838 PyObject * obj1 = 0 ;
17839 char *kwnames[] = {
17840 (char *) "self",(char *) "m_metaDown", NULL
17841 };
17842
17843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17845 if (SWIG_arg_fail(1)) SWIG_fail;
17846 {
17847 arg2 = (bool)(SWIG_As_bool(obj1));
17848 if (SWIG_arg_fail(2)) SWIG_fail;
17849 }
17850 if (arg1) (arg1)->m_metaDown = arg2;
17851
17852 Py_INCREF(Py_None); resultobj = Py_None;
17853 return resultobj;
17854 fail:
17855 return NULL;
17856 }
17857
17858
17859 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17860 PyObject *resultobj;
17861 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17862 bool result;
17863 PyObject * obj0 = 0 ;
17864 char *kwnames[] = {
17865 (char *) "self", NULL
17866 };
17867
17868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17870 if (SWIG_arg_fail(1)) SWIG_fail;
17871 result = (bool) ((arg1)->m_metaDown);
17872
17873 {
17874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17875 }
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17883 PyObject *resultobj;
17884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17885 int arg2 ;
17886 PyObject * obj0 = 0 ;
17887 PyObject * obj1 = 0 ;
17888 char *kwnames[] = {
17889 (char *) "self",(char *) "m_wheelRotation", NULL
17890 };
17891
17892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17894 if (SWIG_arg_fail(1)) SWIG_fail;
17895 {
17896 arg2 = (int)(SWIG_As_int(obj1));
17897 if (SWIG_arg_fail(2)) SWIG_fail;
17898 }
17899 if (arg1) (arg1)->m_wheelRotation = arg2;
17900
17901 Py_INCREF(Py_None); resultobj = Py_None;
17902 return resultobj;
17903 fail:
17904 return NULL;
17905 }
17906
17907
17908 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17909 PyObject *resultobj;
17910 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17911 int result;
17912 PyObject * obj0 = 0 ;
17913 char *kwnames[] = {
17914 (char *) "self", NULL
17915 };
17916
17917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17919 if (SWIG_arg_fail(1)) SWIG_fail;
17920 result = (int) ((arg1)->m_wheelRotation);
17921
17922 {
17923 resultobj = SWIG_From_int((int)(result));
17924 }
17925 return resultobj;
17926 fail:
17927 return NULL;
17928 }
17929
17930
17931 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17932 PyObject *resultobj;
17933 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17934 int arg2 ;
17935 PyObject * obj0 = 0 ;
17936 PyObject * obj1 = 0 ;
17937 char *kwnames[] = {
17938 (char *) "self",(char *) "m_wheelDelta", NULL
17939 };
17940
17941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17943 if (SWIG_arg_fail(1)) SWIG_fail;
17944 {
17945 arg2 = (int)(SWIG_As_int(obj1));
17946 if (SWIG_arg_fail(2)) SWIG_fail;
17947 }
17948 if (arg1) (arg1)->m_wheelDelta = arg2;
17949
17950 Py_INCREF(Py_None); resultobj = Py_None;
17951 return resultobj;
17952 fail:
17953 return NULL;
17954 }
17955
17956
17957 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17958 PyObject *resultobj;
17959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17960 int result;
17961 PyObject * obj0 = 0 ;
17962 char *kwnames[] = {
17963 (char *) "self", NULL
17964 };
17965
17966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17968 if (SWIG_arg_fail(1)) SWIG_fail;
17969 result = (int) ((arg1)->m_wheelDelta);
17970
17971 {
17972 resultobj = SWIG_From_int((int)(result));
17973 }
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17981 PyObject *resultobj;
17982 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17983 int arg2 ;
17984 PyObject * obj0 = 0 ;
17985 PyObject * obj1 = 0 ;
17986 char *kwnames[] = {
17987 (char *) "self",(char *) "m_linesPerAction", NULL
17988 };
17989
17990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17992 if (SWIG_arg_fail(1)) SWIG_fail;
17993 {
17994 arg2 = (int)(SWIG_As_int(obj1));
17995 if (SWIG_arg_fail(2)) SWIG_fail;
17996 }
17997 if (arg1) (arg1)->m_linesPerAction = arg2;
17998
17999 Py_INCREF(Py_None); resultobj = Py_None;
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18007 PyObject *resultobj;
18008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18009 int result;
18010 PyObject * obj0 = 0 ;
18011 char *kwnames[] = {
18012 (char *) "self", NULL
18013 };
18014
18015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18017 if (SWIG_arg_fail(1)) SWIG_fail;
18018 result = (int) ((arg1)->m_linesPerAction);
18019
18020 {
18021 resultobj = SWIG_From_int((int)(result));
18022 }
18023 return resultobj;
18024 fail:
18025 return NULL;
18026 }
18027
18028
18029 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18030 PyObject *obj;
18031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18032 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18033 Py_INCREF(obj);
18034 return Py_BuildValue((char *)"");
18035 }
18036 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18037 PyObject *resultobj;
18038 int arg1 = (int) 0 ;
18039 int arg2 = (int) 0 ;
18040 wxSetCursorEvent *result;
18041 PyObject * obj0 = 0 ;
18042 PyObject * obj1 = 0 ;
18043 char *kwnames[] = {
18044 (char *) "x",(char *) "y", NULL
18045 };
18046
18047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18048 if (obj0) {
18049 {
18050 arg1 = (int)(SWIG_As_int(obj0));
18051 if (SWIG_arg_fail(1)) SWIG_fail;
18052 }
18053 }
18054 if (obj1) {
18055 {
18056 arg2 = (int)(SWIG_As_int(obj1));
18057 if (SWIG_arg_fail(2)) SWIG_fail;
18058 }
18059 }
18060 {
18061 PyThreadState* __tstate = wxPyBeginAllowThreads();
18062 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18063
18064 wxPyEndAllowThreads(__tstate);
18065 if (PyErr_Occurred()) SWIG_fail;
18066 }
18067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18068 return resultobj;
18069 fail:
18070 return NULL;
18071 }
18072
18073
18074 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18075 PyObject *resultobj;
18076 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18077 int result;
18078 PyObject * obj0 = 0 ;
18079 char *kwnames[] = {
18080 (char *) "self", NULL
18081 };
18082
18083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18085 if (SWIG_arg_fail(1)) SWIG_fail;
18086 {
18087 PyThreadState* __tstate = wxPyBeginAllowThreads();
18088 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18089
18090 wxPyEndAllowThreads(__tstate);
18091 if (PyErr_Occurred()) SWIG_fail;
18092 }
18093 {
18094 resultobj = SWIG_From_int((int)(result));
18095 }
18096 return resultobj;
18097 fail:
18098 return NULL;
18099 }
18100
18101
18102 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18103 PyObject *resultobj;
18104 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18105 int result;
18106 PyObject * obj0 = 0 ;
18107 char *kwnames[] = {
18108 (char *) "self", NULL
18109 };
18110
18111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18113 if (SWIG_arg_fail(1)) SWIG_fail;
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18117
18118 wxPyEndAllowThreads(__tstate);
18119 if (PyErr_Occurred()) SWIG_fail;
18120 }
18121 {
18122 resultobj = SWIG_From_int((int)(result));
18123 }
18124 return resultobj;
18125 fail:
18126 return NULL;
18127 }
18128
18129
18130 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18131 PyObject *resultobj;
18132 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18133 wxCursor *arg2 = 0 ;
18134 PyObject * obj0 = 0 ;
18135 PyObject * obj1 = 0 ;
18136 char *kwnames[] = {
18137 (char *) "self",(char *) "cursor", NULL
18138 };
18139
18140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18142 if (SWIG_arg_fail(1)) SWIG_fail;
18143 {
18144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18145 if (SWIG_arg_fail(2)) SWIG_fail;
18146 if (arg2 == NULL) {
18147 SWIG_null_ref("wxCursor");
18148 }
18149 if (SWIG_arg_fail(2)) SWIG_fail;
18150 }
18151 {
18152 PyThreadState* __tstate = wxPyBeginAllowThreads();
18153 (arg1)->SetCursor((wxCursor const &)*arg2);
18154
18155 wxPyEndAllowThreads(__tstate);
18156 if (PyErr_Occurred()) SWIG_fail;
18157 }
18158 Py_INCREF(Py_None); resultobj = Py_None;
18159 return resultobj;
18160 fail:
18161 return NULL;
18162 }
18163
18164
18165 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18166 PyObject *resultobj;
18167 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18168 wxCursor *result;
18169 PyObject * obj0 = 0 ;
18170 char *kwnames[] = {
18171 (char *) "self", NULL
18172 };
18173
18174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18176 if (SWIG_arg_fail(1)) SWIG_fail;
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 {
18180 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18181 result = (wxCursor *) &_result_ref;
18182 }
18183
18184 wxPyEndAllowThreads(__tstate);
18185 if (PyErr_Occurred()) SWIG_fail;
18186 }
18187 {
18188 wxCursor* resultptr = new wxCursor(*result);
18189 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18190 }
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18198 PyObject *resultobj;
18199 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18200 bool result;
18201 PyObject * obj0 = 0 ;
18202 char *kwnames[] = {
18203 (char *) "self", NULL
18204 };
18205
18206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18208 if (SWIG_arg_fail(1)) SWIG_fail;
18209 {
18210 PyThreadState* __tstate = wxPyBeginAllowThreads();
18211 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18212
18213 wxPyEndAllowThreads(__tstate);
18214 if (PyErr_Occurred()) SWIG_fail;
18215 }
18216 {
18217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18218 }
18219 return resultobj;
18220 fail:
18221 return NULL;
18222 }
18223
18224
18225 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18226 PyObject *obj;
18227 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18228 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18229 Py_INCREF(obj);
18230 return Py_BuildValue((char *)"");
18231 }
18232 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18233 PyObject *resultobj;
18234 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18235 wxKeyEvent *result;
18236 PyObject * obj0 = 0 ;
18237 char *kwnames[] = {
18238 (char *) "keyType", NULL
18239 };
18240
18241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18242 if (obj0) {
18243 {
18244 arg1 = (wxEventType)(SWIG_As_int(obj0));
18245 if (SWIG_arg_fail(1)) SWIG_fail;
18246 }
18247 }
18248 {
18249 PyThreadState* __tstate = wxPyBeginAllowThreads();
18250 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18251
18252 wxPyEndAllowThreads(__tstate);
18253 if (PyErr_Occurred()) SWIG_fail;
18254 }
18255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18256 return resultobj;
18257 fail:
18258 return NULL;
18259 }
18260
18261
18262 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18263 PyObject *resultobj;
18264 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18265 bool result;
18266 PyObject * obj0 = 0 ;
18267 char *kwnames[] = {
18268 (char *) "self", NULL
18269 };
18270
18271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18273 if (SWIG_arg_fail(1)) SWIG_fail;
18274 {
18275 PyThreadState* __tstate = wxPyBeginAllowThreads();
18276 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18277
18278 wxPyEndAllowThreads(__tstate);
18279 if (PyErr_Occurred()) SWIG_fail;
18280 }
18281 {
18282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18283 }
18284 return resultobj;
18285 fail:
18286 return NULL;
18287 }
18288
18289
18290 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18291 PyObject *resultobj;
18292 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18293 bool result;
18294 PyObject * obj0 = 0 ;
18295 char *kwnames[] = {
18296 (char *) "self", NULL
18297 };
18298
18299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18301 if (SWIG_arg_fail(1)) SWIG_fail;
18302 {
18303 PyThreadState* __tstate = wxPyBeginAllowThreads();
18304 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18305
18306 wxPyEndAllowThreads(__tstate);
18307 if (PyErr_Occurred()) SWIG_fail;
18308 }
18309 {
18310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18311 }
18312 return resultobj;
18313 fail:
18314 return NULL;
18315 }
18316
18317
18318 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18319 PyObject *resultobj;
18320 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18321 bool result;
18322 PyObject * obj0 = 0 ;
18323 char *kwnames[] = {
18324 (char *) "self", NULL
18325 };
18326
18327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18329 if (SWIG_arg_fail(1)) SWIG_fail;
18330 {
18331 PyThreadState* __tstate = wxPyBeginAllowThreads();
18332 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18333
18334 wxPyEndAllowThreads(__tstate);
18335 if (PyErr_Occurred()) SWIG_fail;
18336 }
18337 {
18338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18339 }
18340 return resultobj;
18341 fail:
18342 return NULL;
18343 }
18344
18345
18346 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18347 PyObject *resultobj;
18348 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18349 bool result;
18350 PyObject * obj0 = 0 ;
18351 char *kwnames[] = {
18352 (char *) "self", NULL
18353 };
18354
18355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18357 if (SWIG_arg_fail(1)) SWIG_fail;
18358 {
18359 PyThreadState* __tstate = wxPyBeginAllowThreads();
18360 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18361
18362 wxPyEndAllowThreads(__tstate);
18363 if (PyErr_Occurred()) SWIG_fail;
18364 }
18365 {
18366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18367 }
18368 return resultobj;
18369 fail:
18370 return NULL;
18371 }
18372
18373
18374 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18375 PyObject *resultobj;
18376 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18377 bool result;
18378 PyObject * obj0 = 0 ;
18379 char *kwnames[] = {
18380 (char *) "self", NULL
18381 };
18382
18383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18385 if (SWIG_arg_fail(1)) SWIG_fail;
18386 {
18387 PyThreadState* __tstate = wxPyBeginAllowThreads();
18388 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18389
18390 wxPyEndAllowThreads(__tstate);
18391 if (PyErr_Occurred()) SWIG_fail;
18392 }
18393 {
18394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18395 }
18396 return resultobj;
18397 fail:
18398 return NULL;
18399 }
18400
18401
18402 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18403 PyObject *resultobj;
18404 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18405 bool result;
18406 PyObject * obj0 = 0 ;
18407 char *kwnames[] = {
18408 (char *) "self", NULL
18409 };
18410
18411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18413 if (SWIG_arg_fail(1)) SWIG_fail;
18414 {
18415 PyThreadState* __tstate = wxPyBeginAllowThreads();
18416 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18417
18418 wxPyEndAllowThreads(__tstate);
18419 if (PyErr_Occurred()) SWIG_fail;
18420 }
18421 {
18422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18423 }
18424 return resultobj;
18425 fail:
18426 return NULL;
18427 }
18428
18429
18430 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18431 PyObject *resultobj;
18432 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18433 int result;
18434 PyObject * obj0 = 0 ;
18435 char *kwnames[] = {
18436 (char *) "self", NULL
18437 };
18438
18439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18441 if (SWIG_arg_fail(1)) SWIG_fail;
18442 {
18443 PyThreadState* __tstate = wxPyBeginAllowThreads();
18444 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18445
18446 wxPyEndAllowThreads(__tstate);
18447 if (PyErr_Occurred()) SWIG_fail;
18448 }
18449 {
18450 resultobj = SWIG_From_int((int)(result));
18451 }
18452 return resultobj;
18453 fail:
18454 return NULL;
18455 }
18456
18457
18458 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18459 PyObject *resultobj;
18460 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18461 int result;
18462 PyObject * obj0 = 0 ;
18463 char *kwnames[] = {
18464 (char *) "self", NULL
18465 };
18466
18467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18469 if (SWIG_arg_fail(1)) SWIG_fail;
18470 {
18471 PyThreadState* __tstate = wxPyBeginAllowThreads();
18472 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18473
18474 wxPyEndAllowThreads(__tstate);
18475 if (PyErr_Occurred()) SWIG_fail;
18476 }
18477 {
18478 resultobj = SWIG_From_int((int)(result));
18479 }
18480 return resultobj;
18481 fail:
18482 return NULL;
18483 }
18484
18485
18486 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18487 PyObject *resultobj;
18488 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18489 unsigned int result;
18490 PyObject * obj0 = 0 ;
18491 char *kwnames[] = {
18492 (char *) "self", NULL
18493 };
18494
18495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18497 if (SWIG_arg_fail(1)) SWIG_fail;
18498 {
18499 PyThreadState* __tstate = wxPyBeginAllowThreads();
18500 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18501
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 {
18506 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18507 }
18508 return resultobj;
18509 fail:
18510 return NULL;
18511 }
18512
18513
18514 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18515 PyObject *resultobj;
18516 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18517 unsigned int result;
18518 PyObject * obj0 = 0 ;
18519 char *kwnames[] = {
18520 (char *) "self", NULL
18521 };
18522
18523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18525 if (SWIG_arg_fail(1)) SWIG_fail;
18526 {
18527 PyThreadState* __tstate = wxPyBeginAllowThreads();
18528 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18529
18530 wxPyEndAllowThreads(__tstate);
18531 if (PyErr_Occurred()) SWIG_fail;
18532 }
18533 {
18534 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18535 }
18536 return resultobj;
18537 fail:
18538 return NULL;
18539 }
18540
18541
18542 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18543 PyObject *resultobj;
18544 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18545 wxPoint result;
18546 PyObject * obj0 = 0 ;
18547 char *kwnames[] = {
18548 (char *) "self", NULL
18549 };
18550
18551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18553 if (SWIG_arg_fail(1)) SWIG_fail;
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 result = (arg1)->GetPosition();
18557
18558 wxPyEndAllowThreads(__tstate);
18559 if (PyErr_Occurred()) SWIG_fail;
18560 }
18561 {
18562 wxPoint * resultptr;
18563 resultptr = new wxPoint((wxPoint &)(result));
18564 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18565 }
18566 return resultobj;
18567 fail:
18568 return NULL;
18569 }
18570
18571
18572 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18573 PyObject *resultobj;
18574 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18575 long *arg2 = (long *) 0 ;
18576 long *arg3 = (long *) 0 ;
18577 long temp2 ;
18578 int res2 = 0 ;
18579 long temp3 ;
18580 int res3 = 0 ;
18581 PyObject * obj0 = 0 ;
18582 char *kwnames[] = {
18583 (char *) "self", NULL
18584 };
18585
18586 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18587 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18590 if (SWIG_arg_fail(1)) SWIG_fail;
18591 {
18592 PyThreadState* __tstate = wxPyBeginAllowThreads();
18593 (arg1)->GetPosition(arg2,arg3);
18594
18595 wxPyEndAllowThreads(__tstate);
18596 if (PyErr_Occurred()) SWIG_fail;
18597 }
18598 Py_INCREF(Py_None); resultobj = Py_None;
18599 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18600 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18601 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18602 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18603 return resultobj;
18604 fail:
18605 return NULL;
18606 }
18607
18608
18609 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18610 PyObject *resultobj;
18611 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18612 int result;
18613 PyObject * obj0 = 0 ;
18614 char *kwnames[] = {
18615 (char *) "self", NULL
18616 };
18617
18618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18620 if (SWIG_arg_fail(1)) SWIG_fail;
18621 {
18622 PyThreadState* __tstate = wxPyBeginAllowThreads();
18623 result = (int)((wxKeyEvent const *)arg1)->GetX();
18624
18625 wxPyEndAllowThreads(__tstate);
18626 if (PyErr_Occurred()) SWIG_fail;
18627 }
18628 {
18629 resultobj = SWIG_From_int((int)(result));
18630 }
18631 return resultobj;
18632 fail:
18633 return NULL;
18634 }
18635
18636
18637 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18638 PyObject *resultobj;
18639 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18640 int result;
18641 PyObject * obj0 = 0 ;
18642 char *kwnames[] = {
18643 (char *) "self", NULL
18644 };
18645
18646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18648 if (SWIG_arg_fail(1)) SWIG_fail;
18649 {
18650 PyThreadState* __tstate = wxPyBeginAllowThreads();
18651 result = (int)((wxKeyEvent const *)arg1)->GetY();
18652
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 {
18657 resultobj = SWIG_From_int((int)(result));
18658 }
18659 return resultobj;
18660 fail:
18661 return NULL;
18662 }
18663
18664
18665 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18666 PyObject *resultobj;
18667 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18668 int arg2 ;
18669 PyObject * obj0 = 0 ;
18670 PyObject * obj1 = 0 ;
18671 char *kwnames[] = {
18672 (char *) "self",(char *) "m_x", NULL
18673 };
18674
18675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18677 if (SWIG_arg_fail(1)) SWIG_fail;
18678 {
18679 arg2 = (int)(SWIG_As_int(obj1));
18680 if (SWIG_arg_fail(2)) SWIG_fail;
18681 }
18682 if (arg1) (arg1)->m_x = arg2;
18683
18684 Py_INCREF(Py_None); resultobj = Py_None;
18685 return resultobj;
18686 fail:
18687 return NULL;
18688 }
18689
18690
18691 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18692 PyObject *resultobj;
18693 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18694 int result;
18695 PyObject * obj0 = 0 ;
18696 char *kwnames[] = {
18697 (char *) "self", NULL
18698 };
18699
18700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) 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 result = (int) ((arg1)->m_x);
18704
18705 {
18706 resultobj = SWIG_From_int((int)(result));
18707 }
18708 return resultobj;
18709 fail:
18710 return NULL;
18711 }
18712
18713
18714 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18715 PyObject *resultobj;
18716 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18717 int arg2 ;
18718 PyObject * obj0 = 0 ;
18719 PyObject * obj1 = 0 ;
18720 char *kwnames[] = {
18721 (char *) "self",(char *) "m_y", NULL
18722 };
18723
18724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18726 if (SWIG_arg_fail(1)) SWIG_fail;
18727 {
18728 arg2 = (int)(SWIG_As_int(obj1));
18729 if (SWIG_arg_fail(2)) SWIG_fail;
18730 }
18731 if (arg1) (arg1)->m_y = arg2;
18732
18733 Py_INCREF(Py_None); resultobj = Py_None;
18734 return resultobj;
18735 fail:
18736 return NULL;
18737 }
18738
18739
18740 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18741 PyObject *resultobj;
18742 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18743 int result;
18744 PyObject * obj0 = 0 ;
18745 char *kwnames[] = {
18746 (char *) "self", NULL
18747 };
18748
18749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) 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 result = (int) ((arg1)->m_y);
18753
18754 {
18755 resultobj = SWIG_From_int((int)(result));
18756 }
18757 return resultobj;
18758 fail:
18759 return NULL;
18760 }
18761
18762
18763 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18764 PyObject *resultobj;
18765 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18766 long arg2 ;
18767 PyObject * obj0 = 0 ;
18768 PyObject * obj1 = 0 ;
18769 char *kwnames[] = {
18770 (char *) "self",(char *) "m_keyCode", NULL
18771 };
18772
18773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18775 if (SWIG_arg_fail(1)) SWIG_fail;
18776 {
18777 arg2 = (long)(SWIG_As_long(obj1));
18778 if (SWIG_arg_fail(2)) SWIG_fail;
18779 }
18780 if (arg1) (arg1)->m_keyCode = arg2;
18781
18782 Py_INCREF(Py_None); resultobj = Py_None;
18783 return resultobj;
18784 fail:
18785 return NULL;
18786 }
18787
18788
18789 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18790 PyObject *resultobj;
18791 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18792 long result;
18793 PyObject * obj0 = 0 ;
18794 char *kwnames[] = {
18795 (char *) "self", NULL
18796 };
18797
18798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18800 if (SWIG_arg_fail(1)) SWIG_fail;
18801 result = (long) ((arg1)->m_keyCode);
18802
18803 {
18804 resultobj = SWIG_From_long((long)(result));
18805 }
18806 return resultobj;
18807 fail:
18808 return NULL;
18809 }
18810
18811
18812 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18813 PyObject *resultobj;
18814 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18815 bool arg2 ;
18816 PyObject * obj0 = 0 ;
18817 PyObject * obj1 = 0 ;
18818 char *kwnames[] = {
18819 (char *) "self",(char *) "m_controlDown", NULL
18820 };
18821
18822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18824 if (SWIG_arg_fail(1)) SWIG_fail;
18825 {
18826 arg2 = (bool)(SWIG_As_bool(obj1));
18827 if (SWIG_arg_fail(2)) SWIG_fail;
18828 }
18829 if (arg1) (arg1)->m_controlDown = arg2;
18830
18831 Py_INCREF(Py_None); resultobj = Py_None;
18832 return resultobj;
18833 fail:
18834 return NULL;
18835 }
18836
18837
18838 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18839 PyObject *resultobj;
18840 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18841 bool result;
18842 PyObject * obj0 = 0 ;
18843 char *kwnames[] = {
18844 (char *) "self", NULL
18845 };
18846
18847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18849 if (SWIG_arg_fail(1)) SWIG_fail;
18850 result = (bool) ((arg1)->m_controlDown);
18851
18852 {
18853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18854 }
18855 return resultobj;
18856 fail:
18857 return NULL;
18858 }
18859
18860
18861 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18862 PyObject *resultobj;
18863 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18864 bool arg2 ;
18865 PyObject * obj0 = 0 ;
18866 PyObject * obj1 = 0 ;
18867 char *kwnames[] = {
18868 (char *) "self",(char *) "m_shiftDown", NULL
18869 };
18870
18871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18873 if (SWIG_arg_fail(1)) SWIG_fail;
18874 {
18875 arg2 = (bool)(SWIG_As_bool(obj1));
18876 if (SWIG_arg_fail(2)) SWIG_fail;
18877 }
18878 if (arg1) (arg1)->m_shiftDown = arg2;
18879
18880 Py_INCREF(Py_None); resultobj = Py_None;
18881 return resultobj;
18882 fail:
18883 return NULL;
18884 }
18885
18886
18887 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18888 PyObject *resultobj;
18889 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18890 bool result;
18891 PyObject * obj0 = 0 ;
18892 char *kwnames[] = {
18893 (char *) "self", NULL
18894 };
18895
18896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18898 if (SWIG_arg_fail(1)) SWIG_fail;
18899 result = (bool) ((arg1)->m_shiftDown);
18900
18901 {
18902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18903 }
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj;
18912 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18913 bool arg2 ;
18914 PyObject * obj0 = 0 ;
18915 PyObject * obj1 = 0 ;
18916 char *kwnames[] = {
18917 (char *) "self",(char *) "m_altDown", NULL
18918 };
18919
18920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18922 if (SWIG_arg_fail(1)) SWIG_fail;
18923 {
18924 arg2 = (bool)(SWIG_As_bool(obj1));
18925 if (SWIG_arg_fail(2)) SWIG_fail;
18926 }
18927 if (arg1) (arg1)->m_altDown = arg2;
18928
18929 Py_INCREF(Py_None); resultobj = Py_None;
18930 return resultobj;
18931 fail:
18932 return NULL;
18933 }
18934
18935
18936 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18937 PyObject *resultobj;
18938 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18939 bool result;
18940 PyObject * obj0 = 0 ;
18941 char *kwnames[] = {
18942 (char *) "self", NULL
18943 };
18944
18945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18947 if (SWIG_arg_fail(1)) SWIG_fail;
18948 result = (bool) ((arg1)->m_altDown);
18949
18950 {
18951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18952 }
18953 return resultobj;
18954 fail:
18955 return NULL;
18956 }
18957
18958
18959 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18960 PyObject *resultobj;
18961 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18962 bool arg2 ;
18963 PyObject * obj0 = 0 ;
18964 PyObject * obj1 = 0 ;
18965 char *kwnames[] = {
18966 (char *) "self",(char *) "m_metaDown", NULL
18967 };
18968
18969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18971 if (SWIG_arg_fail(1)) SWIG_fail;
18972 {
18973 arg2 = (bool)(SWIG_As_bool(obj1));
18974 if (SWIG_arg_fail(2)) SWIG_fail;
18975 }
18976 if (arg1) (arg1)->m_metaDown = arg2;
18977
18978 Py_INCREF(Py_None); resultobj = Py_None;
18979 return resultobj;
18980 fail:
18981 return NULL;
18982 }
18983
18984
18985 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18986 PyObject *resultobj;
18987 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18988 bool result;
18989 PyObject * obj0 = 0 ;
18990 char *kwnames[] = {
18991 (char *) "self", NULL
18992 };
18993
18994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18996 if (SWIG_arg_fail(1)) SWIG_fail;
18997 result = (bool) ((arg1)->m_metaDown);
18998
18999 {
19000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19001 }
19002 return resultobj;
19003 fail:
19004 return NULL;
19005 }
19006
19007
19008 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19009 PyObject *resultobj;
19010 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19011 bool arg2 ;
19012 PyObject * obj0 = 0 ;
19013 PyObject * obj1 = 0 ;
19014 char *kwnames[] = {
19015 (char *) "self",(char *) "m_scanCode", NULL
19016 };
19017
19018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19020 if (SWIG_arg_fail(1)) SWIG_fail;
19021 {
19022 arg2 = (bool)(SWIG_As_bool(obj1));
19023 if (SWIG_arg_fail(2)) SWIG_fail;
19024 }
19025 if (arg1) (arg1)->m_scanCode = arg2;
19026
19027 Py_INCREF(Py_None); resultobj = Py_None;
19028 return resultobj;
19029 fail:
19030 return NULL;
19031 }
19032
19033
19034 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj;
19036 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19037 bool result;
19038 PyObject * obj0 = 0 ;
19039 char *kwnames[] = {
19040 (char *) "self", NULL
19041 };
19042
19043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19045 if (SWIG_arg_fail(1)) SWIG_fail;
19046 result = (bool) ((arg1)->m_scanCode);
19047
19048 {
19049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19050 }
19051 return resultobj;
19052 fail:
19053 return NULL;
19054 }
19055
19056
19057 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19058 PyObject *resultobj;
19059 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19060 unsigned int arg2 ;
19061 PyObject * obj0 = 0 ;
19062 PyObject * obj1 = 0 ;
19063 char *kwnames[] = {
19064 (char *) "self",(char *) "m_rawCode", NULL
19065 };
19066
19067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19069 if (SWIG_arg_fail(1)) SWIG_fail;
19070 {
19071 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19072 if (SWIG_arg_fail(2)) SWIG_fail;
19073 }
19074 if (arg1) (arg1)->m_rawCode = arg2;
19075
19076 Py_INCREF(Py_None); resultobj = Py_None;
19077 return resultobj;
19078 fail:
19079 return NULL;
19080 }
19081
19082
19083 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19084 PyObject *resultobj;
19085 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19086 unsigned int result;
19087 PyObject * obj0 = 0 ;
19088 char *kwnames[] = {
19089 (char *) "self", NULL
19090 };
19091
19092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19094 if (SWIG_arg_fail(1)) SWIG_fail;
19095 result = (unsigned int) ((arg1)->m_rawCode);
19096
19097 {
19098 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19099 }
19100 return resultobj;
19101 fail:
19102 return NULL;
19103 }
19104
19105
19106 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj;
19108 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19109 unsigned int arg2 ;
19110 PyObject * obj0 = 0 ;
19111 PyObject * obj1 = 0 ;
19112 char *kwnames[] = {
19113 (char *) "self",(char *) "m_rawFlags", NULL
19114 };
19115
19116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19118 if (SWIG_arg_fail(1)) SWIG_fail;
19119 {
19120 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19121 if (SWIG_arg_fail(2)) SWIG_fail;
19122 }
19123 if (arg1) (arg1)->m_rawFlags = arg2;
19124
19125 Py_INCREF(Py_None); resultobj = Py_None;
19126 return resultobj;
19127 fail:
19128 return NULL;
19129 }
19130
19131
19132 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19133 PyObject *resultobj;
19134 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19135 unsigned int result;
19136 PyObject * obj0 = 0 ;
19137 char *kwnames[] = {
19138 (char *) "self", NULL
19139 };
19140
19141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19143 if (SWIG_arg_fail(1)) SWIG_fail;
19144 result = (unsigned int) ((arg1)->m_rawFlags);
19145
19146 {
19147 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19148 }
19149 return resultobj;
19150 fail:
19151 return NULL;
19152 }
19153
19154
19155 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19156 PyObject *obj;
19157 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19158 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19159 Py_INCREF(obj);
19160 return Py_BuildValue((char *)"");
19161 }
19162 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj;
19164 wxSize const &arg1_defvalue = wxDefaultSize ;
19165 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19166 int arg2 = (int) 0 ;
19167 wxSizeEvent *result;
19168 wxSize temp1 ;
19169 PyObject * obj0 = 0 ;
19170 PyObject * obj1 = 0 ;
19171 char *kwnames[] = {
19172 (char *) "sz",(char *) "winid", NULL
19173 };
19174
19175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19176 if (obj0) {
19177 {
19178 arg1 = &temp1;
19179 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19180 }
19181 }
19182 if (obj1) {
19183 {
19184 arg2 = (int)(SWIG_As_int(obj1));
19185 if (SWIG_arg_fail(2)) SWIG_fail;
19186 }
19187 }
19188 {
19189 PyThreadState* __tstate = wxPyBeginAllowThreads();
19190 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19191
19192 wxPyEndAllowThreads(__tstate);
19193 if (PyErr_Occurred()) SWIG_fail;
19194 }
19195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19203 PyObject *resultobj;
19204 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19205 wxSize result;
19206 PyObject * obj0 = 0 ;
19207 char *kwnames[] = {
19208 (char *) "self", NULL
19209 };
19210
19211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19213 if (SWIG_arg_fail(1)) SWIG_fail;
19214 {
19215 PyThreadState* __tstate = wxPyBeginAllowThreads();
19216 result = ((wxSizeEvent const *)arg1)->GetSize();
19217
19218 wxPyEndAllowThreads(__tstate);
19219 if (PyErr_Occurred()) SWIG_fail;
19220 }
19221 {
19222 wxSize * resultptr;
19223 resultptr = new wxSize((wxSize &)(result));
19224 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19225 }
19226 return resultobj;
19227 fail:
19228 return NULL;
19229 }
19230
19231
19232 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19233 PyObject *resultobj;
19234 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19235 wxRect result;
19236 PyObject * obj0 = 0 ;
19237 char *kwnames[] = {
19238 (char *) "self", NULL
19239 };
19240
19241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19243 if (SWIG_arg_fail(1)) SWIG_fail;
19244 {
19245 PyThreadState* __tstate = wxPyBeginAllowThreads();
19246 result = ((wxSizeEvent const *)arg1)->GetRect();
19247
19248 wxPyEndAllowThreads(__tstate);
19249 if (PyErr_Occurred()) SWIG_fail;
19250 }
19251 {
19252 wxRect * resultptr;
19253 resultptr = new wxRect((wxRect &)(result));
19254 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19255 }
19256 return resultobj;
19257 fail:
19258 return NULL;
19259 }
19260
19261
19262 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19263 PyObject *resultobj;
19264 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19265 wxRect arg2 ;
19266 PyObject * obj0 = 0 ;
19267 PyObject * obj1 = 0 ;
19268 char *kwnames[] = {
19269 (char *) "self",(char *) "rect", NULL
19270 };
19271
19272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19274 if (SWIG_arg_fail(1)) SWIG_fail;
19275 {
19276 wxRect * argp;
19277 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19278 if (SWIG_arg_fail(2)) SWIG_fail;
19279 if (argp == NULL) {
19280 SWIG_null_ref("wxRect");
19281 }
19282 if (SWIG_arg_fail(2)) SWIG_fail;
19283 arg2 = *argp;
19284 }
19285 {
19286 PyThreadState* __tstate = wxPyBeginAllowThreads();
19287 (arg1)->SetRect(arg2);
19288
19289 wxPyEndAllowThreads(__tstate);
19290 if (PyErr_Occurred()) SWIG_fail;
19291 }
19292 Py_INCREF(Py_None); resultobj = Py_None;
19293 return resultobj;
19294 fail:
19295 return NULL;
19296 }
19297
19298
19299 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19300 PyObject *resultobj;
19301 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19302 wxSize arg2 ;
19303 PyObject * obj0 = 0 ;
19304 PyObject * obj1 = 0 ;
19305 char *kwnames[] = {
19306 (char *) "self",(char *) "size", NULL
19307 };
19308
19309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19311 if (SWIG_arg_fail(1)) SWIG_fail;
19312 {
19313 wxSize * argp;
19314 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19315 if (SWIG_arg_fail(2)) SWIG_fail;
19316 if (argp == NULL) {
19317 SWIG_null_ref("wxSize");
19318 }
19319 if (SWIG_arg_fail(2)) SWIG_fail;
19320 arg2 = *argp;
19321 }
19322 {
19323 PyThreadState* __tstate = wxPyBeginAllowThreads();
19324 wxSizeEvent_SetSize(arg1,arg2);
19325
19326 wxPyEndAllowThreads(__tstate);
19327 if (PyErr_Occurred()) SWIG_fail;
19328 }
19329 Py_INCREF(Py_None); resultobj = Py_None;
19330 return resultobj;
19331 fail:
19332 return NULL;
19333 }
19334
19335
19336 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19337 PyObject *resultobj;
19338 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19339 wxSize *arg2 = (wxSize *) 0 ;
19340 PyObject * obj0 = 0 ;
19341 PyObject * obj1 = 0 ;
19342 char *kwnames[] = {
19343 (char *) "self",(char *) "m_size", NULL
19344 };
19345
19346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19348 if (SWIG_arg_fail(1)) SWIG_fail;
19349 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19350 if (SWIG_arg_fail(2)) SWIG_fail;
19351 if (arg1) (arg1)->m_size = *arg2;
19352
19353 Py_INCREF(Py_None); resultobj = Py_None;
19354 return resultobj;
19355 fail:
19356 return NULL;
19357 }
19358
19359
19360 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19361 PyObject *resultobj;
19362 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19363 wxSize *result;
19364 PyObject * obj0 = 0 ;
19365 char *kwnames[] = {
19366 (char *) "self", NULL
19367 };
19368
19369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19371 if (SWIG_arg_fail(1)) SWIG_fail;
19372 result = (wxSize *)& ((arg1)->m_size);
19373
19374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19375 return resultobj;
19376 fail:
19377 return NULL;
19378 }
19379
19380
19381 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19382 PyObject *resultobj;
19383 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19384 wxRect *arg2 = (wxRect *) 0 ;
19385 PyObject * obj0 = 0 ;
19386 PyObject * obj1 = 0 ;
19387 char *kwnames[] = {
19388 (char *) "self",(char *) "m_rect", NULL
19389 };
19390
19391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19393 if (SWIG_arg_fail(1)) SWIG_fail;
19394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19395 if (SWIG_arg_fail(2)) SWIG_fail;
19396 if (arg1) (arg1)->m_rect = *arg2;
19397
19398 Py_INCREF(Py_None); resultobj = Py_None;
19399 return resultobj;
19400 fail:
19401 return NULL;
19402 }
19403
19404
19405 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19406 PyObject *resultobj;
19407 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19408 wxRect *result;
19409 PyObject * obj0 = 0 ;
19410 char *kwnames[] = {
19411 (char *) "self", NULL
19412 };
19413
19414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19416 if (SWIG_arg_fail(1)) SWIG_fail;
19417 result = (wxRect *)& ((arg1)->m_rect);
19418
19419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19427 PyObject *obj;
19428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19429 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19430 Py_INCREF(obj);
19431 return Py_BuildValue((char *)"");
19432 }
19433 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19434 PyObject *resultobj;
19435 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19436 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19437 int arg2 = (int) 0 ;
19438 wxMoveEvent *result;
19439 wxPoint temp1 ;
19440 PyObject * obj0 = 0 ;
19441 PyObject * obj1 = 0 ;
19442 char *kwnames[] = {
19443 (char *) "pos",(char *) "winid", NULL
19444 };
19445
19446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19447 if (obj0) {
19448 {
19449 arg1 = &temp1;
19450 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19451 }
19452 }
19453 if (obj1) {
19454 {
19455 arg2 = (int)(SWIG_As_int(obj1));
19456 if (SWIG_arg_fail(2)) SWIG_fail;
19457 }
19458 }
19459 {
19460 PyThreadState* __tstate = wxPyBeginAllowThreads();
19461 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19462
19463 wxPyEndAllowThreads(__tstate);
19464 if (PyErr_Occurred()) SWIG_fail;
19465 }
19466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19467 return resultobj;
19468 fail:
19469 return NULL;
19470 }
19471
19472
19473 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19474 PyObject *resultobj;
19475 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19476 wxPoint result;
19477 PyObject * obj0 = 0 ;
19478 char *kwnames[] = {
19479 (char *) "self", NULL
19480 };
19481
19482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19484 if (SWIG_arg_fail(1)) SWIG_fail;
19485 {
19486 PyThreadState* __tstate = wxPyBeginAllowThreads();
19487 result = ((wxMoveEvent const *)arg1)->GetPosition();
19488
19489 wxPyEndAllowThreads(__tstate);
19490 if (PyErr_Occurred()) SWIG_fail;
19491 }
19492 {
19493 wxPoint * resultptr;
19494 resultptr = new wxPoint((wxPoint &)(result));
19495 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19496 }
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19504 PyObject *resultobj;
19505 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19506 wxRect result;
19507 PyObject * obj0 = 0 ;
19508 char *kwnames[] = {
19509 (char *) "self", NULL
19510 };
19511
19512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19514 if (SWIG_arg_fail(1)) SWIG_fail;
19515 {
19516 PyThreadState* __tstate = wxPyBeginAllowThreads();
19517 result = ((wxMoveEvent const *)arg1)->GetRect();
19518
19519 wxPyEndAllowThreads(__tstate);
19520 if (PyErr_Occurred()) SWIG_fail;
19521 }
19522 {
19523 wxRect * resultptr;
19524 resultptr = new wxRect((wxRect &)(result));
19525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19526 }
19527 return resultobj;
19528 fail:
19529 return NULL;
19530 }
19531
19532
19533 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19534 PyObject *resultobj;
19535 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19536 wxRect *arg2 = 0 ;
19537 wxRect temp2 ;
19538 PyObject * obj0 = 0 ;
19539 PyObject * obj1 = 0 ;
19540 char *kwnames[] = {
19541 (char *) "self",(char *) "rect", NULL
19542 };
19543
19544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19546 if (SWIG_arg_fail(1)) SWIG_fail;
19547 {
19548 arg2 = &temp2;
19549 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19550 }
19551 {
19552 PyThreadState* __tstate = wxPyBeginAllowThreads();
19553 (arg1)->SetRect((wxRect const &)*arg2);
19554
19555 wxPyEndAllowThreads(__tstate);
19556 if (PyErr_Occurred()) SWIG_fail;
19557 }
19558 Py_INCREF(Py_None); resultobj = Py_None;
19559 return resultobj;
19560 fail:
19561 return NULL;
19562 }
19563
19564
19565 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19566 PyObject *resultobj;
19567 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19568 wxPoint *arg2 = 0 ;
19569 wxPoint temp2 ;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 char *kwnames[] = {
19573 (char *) "self",(char *) "pos", NULL
19574 };
19575
19576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19578 if (SWIG_arg_fail(1)) SWIG_fail;
19579 {
19580 arg2 = &temp2;
19581 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19582 }
19583 {
19584 PyThreadState* __tstate = wxPyBeginAllowThreads();
19585 (arg1)->SetPosition((wxPoint const &)*arg2);
19586
19587 wxPyEndAllowThreads(__tstate);
19588 if (PyErr_Occurred()) SWIG_fail;
19589 }
19590 Py_INCREF(Py_None); resultobj = Py_None;
19591 return resultobj;
19592 fail:
19593 return NULL;
19594 }
19595
19596
19597 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19598 PyObject *obj;
19599 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19600 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19601 Py_INCREF(obj);
19602 return Py_BuildValue((char *)"");
19603 }
19604 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19605 PyObject *resultobj;
19606 int arg1 = (int) 0 ;
19607 wxPaintEvent *result;
19608 PyObject * obj0 = 0 ;
19609 char *kwnames[] = {
19610 (char *) "Id", NULL
19611 };
19612
19613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19614 if (obj0) {
19615 {
19616 arg1 = (int)(SWIG_As_int(obj0));
19617 if (SWIG_arg_fail(1)) SWIG_fail;
19618 }
19619 }
19620 {
19621 PyThreadState* __tstate = wxPyBeginAllowThreads();
19622 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19623
19624 wxPyEndAllowThreads(__tstate);
19625 if (PyErr_Occurred()) SWIG_fail;
19626 }
19627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19628 return resultobj;
19629 fail:
19630 return NULL;
19631 }
19632
19633
19634 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19635 PyObject *obj;
19636 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19637 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19638 Py_INCREF(obj);
19639 return Py_BuildValue((char *)"");
19640 }
19641 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19642 PyObject *resultobj;
19643 int arg1 = (int) 0 ;
19644 wxNcPaintEvent *result;
19645 PyObject * obj0 = 0 ;
19646 char *kwnames[] = {
19647 (char *) "winid", NULL
19648 };
19649
19650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19651 if (obj0) {
19652 {
19653 arg1 = (int)(SWIG_As_int(obj0));
19654 if (SWIG_arg_fail(1)) SWIG_fail;
19655 }
19656 }
19657 {
19658 PyThreadState* __tstate = wxPyBeginAllowThreads();
19659 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19660
19661 wxPyEndAllowThreads(__tstate);
19662 if (PyErr_Occurred()) SWIG_fail;
19663 }
19664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19665 return resultobj;
19666 fail:
19667 return NULL;
19668 }
19669
19670
19671 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19672 PyObject *obj;
19673 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19674 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19675 Py_INCREF(obj);
19676 return Py_BuildValue((char *)"");
19677 }
19678 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19679 PyObject *resultobj;
19680 int arg1 = (int) 0 ;
19681 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19682 wxEraseEvent *result;
19683 PyObject * obj0 = 0 ;
19684 PyObject * obj1 = 0 ;
19685 char *kwnames[] = {
19686 (char *) "Id",(char *) "dc", NULL
19687 };
19688
19689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19690 if (obj0) {
19691 {
19692 arg1 = (int)(SWIG_As_int(obj0));
19693 if (SWIG_arg_fail(1)) SWIG_fail;
19694 }
19695 }
19696 if (obj1) {
19697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19698 if (SWIG_arg_fail(2)) SWIG_fail;
19699 }
19700 {
19701 PyThreadState* __tstate = wxPyBeginAllowThreads();
19702 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19703
19704 wxPyEndAllowThreads(__tstate);
19705 if (PyErr_Occurred()) SWIG_fail;
19706 }
19707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19708 return resultobj;
19709 fail:
19710 return NULL;
19711 }
19712
19713
19714 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19715 PyObject *resultobj;
19716 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19717 wxDC *result;
19718 PyObject * obj0 = 0 ;
19719 char *kwnames[] = {
19720 (char *) "self", NULL
19721 };
19722
19723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19725 if (SWIG_arg_fail(1)) SWIG_fail;
19726 {
19727 PyThreadState* __tstate = wxPyBeginAllowThreads();
19728 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19729
19730 wxPyEndAllowThreads(__tstate);
19731 if (PyErr_Occurred()) SWIG_fail;
19732 }
19733 {
19734 resultobj = wxPyMake_wxObject(result, 0);
19735 }
19736 return resultobj;
19737 fail:
19738 return NULL;
19739 }
19740
19741
19742 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19743 PyObject *obj;
19744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19745 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19746 Py_INCREF(obj);
19747 return Py_BuildValue((char *)"");
19748 }
19749 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19750 PyObject *resultobj;
19751 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19752 int arg2 = (int) 0 ;
19753 wxFocusEvent *result;
19754 PyObject * obj0 = 0 ;
19755 PyObject * obj1 = 0 ;
19756 char *kwnames[] = {
19757 (char *) "type",(char *) "winid", NULL
19758 };
19759
19760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19761 if (obj0) {
19762 {
19763 arg1 = (wxEventType)(SWIG_As_int(obj0));
19764 if (SWIG_arg_fail(1)) SWIG_fail;
19765 }
19766 }
19767 if (obj1) {
19768 {
19769 arg2 = (int)(SWIG_As_int(obj1));
19770 if (SWIG_arg_fail(2)) SWIG_fail;
19771 }
19772 }
19773 {
19774 PyThreadState* __tstate = wxPyBeginAllowThreads();
19775 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19776
19777 wxPyEndAllowThreads(__tstate);
19778 if (PyErr_Occurred()) SWIG_fail;
19779 }
19780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19781 return resultobj;
19782 fail:
19783 return NULL;
19784 }
19785
19786
19787 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19788 PyObject *resultobj;
19789 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19790 wxWindow *result;
19791 PyObject * obj0 = 0 ;
19792 char *kwnames[] = {
19793 (char *) "self", NULL
19794 };
19795
19796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19798 if (SWIG_arg_fail(1)) SWIG_fail;
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19802
19803 wxPyEndAllowThreads(__tstate);
19804 if (PyErr_Occurred()) SWIG_fail;
19805 }
19806 {
19807 resultobj = wxPyMake_wxObject(result, 0);
19808 }
19809 return resultobj;
19810 fail:
19811 return NULL;
19812 }
19813
19814
19815 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19816 PyObject *resultobj;
19817 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19818 wxWindow *arg2 = (wxWindow *) 0 ;
19819 PyObject * obj0 = 0 ;
19820 PyObject * obj1 = 0 ;
19821 char *kwnames[] = {
19822 (char *) "self",(char *) "win", NULL
19823 };
19824
19825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19827 if (SWIG_arg_fail(1)) SWIG_fail;
19828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19829 if (SWIG_arg_fail(2)) SWIG_fail;
19830 {
19831 PyThreadState* __tstate = wxPyBeginAllowThreads();
19832 (arg1)->SetWindow(arg2);
19833
19834 wxPyEndAllowThreads(__tstate);
19835 if (PyErr_Occurred()) SWIG_fail;
19836 }
19837 Py_INCREF(Py_None); resultobj = Py_None;
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19845 PyObject *obj;
19846 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19847 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19848 Py_INCREF(obj);
19849 return Py_BuildValue((char *)"");
19850 }
19851 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19852 PyObject *resultobj;
19853 wxWindow *arg1 = (wxWindow *) NULL ;
19854 wxChildFocusEvent *result;
19855 PyObject * obj0 = 0 ;
19856 char *kwnames[] = {
19857 (char *) "win", NULL
19858 };
19859
19860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19861 if (obj0) {
19862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19863 if (SWIG_arg_fail(1)) SWIG_fail;
19864 }
19865 {
19866 PyThreadState* __tstate = wxPyBeginAllowThreads();
19867 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19868
19869 wxPyEndAllowThreads(__tstate);
19870 if (PyErr_Occurred()) SWIG_fail;
19871 }
19872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19873 return resultobj;
19874 fail:
19875 return NULL;
19876 }
19877
19878
19879 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19880 PyObject *resultobj;
19881 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19882 wxWindow *result;
19883 PyObject * obj0 = 0 ;
19884 char *kwnames[] = {
19885 (char *) "self", NULL
19886 };
19887
19888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19890 if (SWIG_arg_fail(1)) SWIG_fail;
19891 {
19892 PyThreadState* __tstate = wxPyBeginAllowThreads();
19893 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19894
19895 wxPyEndAllowThreads(__tstate);
19896 if (PyErr_Occurred()) SWIG_fail;
19897 }
19898 {
19899 resultobj = wxPyMake_wxObject(result, 0);
19900 }
19901 return resultobj;
19902 fail:
19903 return NULL;
19904 }
19905
19906
19907 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19908 PyObject *obj;
19909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19910 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19911 Py_INCREF(obj);
19912 return Py_BuildValue((char *)"");
19913 }
19914 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19915 PyObject *resultobj;
19916 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19917 bool arg2 = (bool) true ;
19918 int arg3 = (int) 0 ;
19919 wxActivateEvent *result;
19920 PyObject * obj0 = 0 ;
19921 PyObject * obj1 = 0 ;
19922 PyObject * obj2 = 0 ;
19923 char *kwnames[] = {
19924 (char *) "type",(char *) "active",(char *) "Id", NULL
19925 };
19926
19927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19928 if (obj0) {
19929 {
19930 arg1 = (wxEventType)(SWIG_As_int(obj0));
19931 if (SWIG_arg_fail(1)) SWIG_fail;
19932 }
19933 }
19934 if (obj1) {
19935 {
19936 arg2 = (bool)(SWIG_As_bool(obj1));
19937 if (SWIG_arg_fail(2)) SWIG_fail;
19938 }
19939 }
19940 if (obj2) {
19941 {
19942 arg3 = (int)(SWIG_As_int(obj2));
19943 if (SWIG_arg_fail(3)) SWIG_fail;
19944 }
19945 }
19946 {
19947 PyThreadState* __tstate = wxPyBeginAllowThreads();
19948 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19949
19950 wxPyEndAllowThreads(__tstate);
19951 if (PyErr_Occurred()) SWIG_fail;
19952 }
19953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19954 return resultobj;
19955 fail:
19956 return NULL;
19957 }
19958
19959
19960 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19961 PyObject *resultobj;
19962 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19963 bool result;
19964 PyObject * obj0 = 0 ;
19965 char *kwnames[] = {
19966 (char *) "self", NULL
19967 };
19968
19969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19971 if (SWIG_arg_fail(1)) SWIG_fail;
19972 {
19973 PyThreadState* __tstate = wxPyBeginAllowThreads();
19974 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19975
19976 wxPyEndAllowThreads(__tstate);
19977 if (PyErr_Occurred()) SWIG_fail;
19978 }
19979 {
19980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19981 }
19982 return resultobj;
19983 fail:
19984 return NULL;
19985 }
19986
19987
19988 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19989 PyObject *obj;
19990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19991 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19992 Py_INCREF(obj);
19993 return Py_BuildValue((char *)"");
19994 }
19995 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19996 PyObject *resultobj;
19997 int arg1 = (int) 0 ;
19998 wxInitDialogEvent *result;
19999 PyObject * obj0 = 0 ;
20000 char *kwnames[] = {
20001 (char *) "Id", NULL
20002 };
20003
20004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20005 if (obj0) {
20006 {
20007 arg1 = (int)(SWIG_As_int(obj0));
20008 if (SWIG_arg_fail(1)) SWIG_fail;
20009 }
20010 }
20011 {
20012 PyThreadState* __tstate = wxPyBeginAllowThreads();
20013 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20014
20015 wxPyEndAllowThreads(__tstate);
20016 if (PyErr_Occurred()) SWIG_fail;
20017 }
20018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20019 return resultobj;
20020 fail:
20021 return NULL;
20022 }
20023
20024
20025 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20026 PyObject *obj;
20027 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20028 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20029 Py_INCREF(obj);
20030 return Py_BuildValue((char *)"");
20031 }
20032 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20033 PyObject *resultobj;
20034 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20035 int arg2 = (int) 0 ;
20036 wxMenu *arg3 = (wxMenu *) NULL ;
20037 wxMenuEvent *result;
20038 PyObject * obj0 = 0 ;
20039 PyObject * obj1 = 0 ;
20040 PyObject * obj2 = 0 ;
20041 char *kwnames[] = {
20042 (char *) "type",(char *) "winid",(char *) "menu", NULL
20043 };
20044
20045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20046 if (obj0) {
20047 {
20048 arg1 = (wxEventType)(SWIG_As_int(obj0));
20049 if (SWIG_arg_fail(1)) SWIG_fail;
20050 }
20051 }
20052 if (obj1) {
20053 {
20054 arg2 = (int)(SWIG_As_int(obj1));
20055 if (SWIG_arg_fail(2)) SWIG_fail;
20056 }
20057 }
20058 if (obj2) {
20059 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20060 if (SWIG_arg_fail(3)) SWIG_fail;
20061 }
20062 {
20063 PyThreadState* __tstate = wxPyBeginAllowThreads();
20064 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20065
20066 wxPyEndAllowThreads(__tstate);
20067 if (PyErr_Occurred()) SWIG_fail;
20068 }
20069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20070 return resultobj;
20071 fail:
20072 return NULL;
20073 }
20074
20075
20076 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20077 PyObject *resultobj;
20078 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20079 int result;
20080 PyObject * obj0 = 0 ;
20081 char *kwnames[] = {
20082 (char *) "self", NULL
20083 };
20084
20085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20087 if (SWIG_arg_fail(1)) SWIG_fail;
20088 {
20089 PyThreadState* __tstate = wxPyBeginAllowThreads();
20090 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20091
20092 wxPyEndAllowThreads(__tstate);
20093 if (PyErr_Occurred()) SWIG_fail;
20094 }
20095 {
20096 resultobj = SWIG_From_int((int)(result));
20097 }
20098 return resultobj;
20099 fail:
20100 return NULL;
20101 }
20102
20103
20104 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20105 PyObject *resultobj;
20106 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20107 bool result;
20108 PyObject * obj0 = 0 ;
20109 char *kwnames[] = {
20110 (char *) "self", NULL
20111 };
20112
20113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20115 if (SWIG_arg_fail(1)) SWIG_fail;
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20119
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 {
20124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20125 }
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj;
20134 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20135 wxMenu *result;
20136 PyObject * obj0 = 0 ;
20137 char *kwnames[] = {
20138 (char *) "self", NULL
20139 };
20140
20141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20143 if (SWIG_arg_fail(1)) SWIG_fail;
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20147
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 {
20152 resultobj = wxPyMake_wxObject(result, 0);
20153 }
20154 return resultobj;
20155 fail:
20156 return NULL;
20157 }
20158
20159
20160 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20161 PyObject *obj;
20162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20163 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20164 Py_INCREF(obj);
20165 return Py_BuildValue((char *)"");
20166 }
20167 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20168 PyObject *resultobj;
20169 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20170 int arg2 = (int) 0 ;
20171 wxCloseEvent *result;
20172 PyObject * obj0 = 0 ;
20173 PyObject * obj1 = 0 ;
20174 char *kwnames[] = {
20175 (char *) "type",(char *) "winid", NULL
20176 };
20177
20178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20179 if (obj0) {
20180 {
20181 arg1 = (wxEventType)(SWIG_As_int(obj0));
20182 if (SWIG_arg_fail(1)) SWIG_fail;
20183 }
20184 }
20185 if (obj1) {
20186 {
20187 arg2 = (int)(SWIG_As_int(obj1));
20188 if (SWIG_arg_fail(2)) SWIG_fail;
20189 }
20190 }
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20194
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20206 PyObject *resultobj;
20207 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20208 bool arg2 ;
20209 PyObject * obj0 = 0 ;
20210 PyObject * obj1 = 0 ;
20211 char *kwnames[] = {
20212 (char *) "self",(char *) "logOff", NULL
20213 };
20214
20215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20217 if (SWIG_arg_fail(1)) SWIG_fail;
20218 {
20219 arg2 = (bool)(SWIG_As_bool(obj1));
20220 if (SWIG_arg_fail(2)) SWIG_fail;
20221 }
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 (arg1)->SetLoggingOff(arg2);
20225
20226 wxPyEndAllowThreads(__tstate);
20227 if (PyErr_Occurred()) SWIG_fail;
20228 }
20229 Py_INCREF(Py_None); resultobj = Py_None;
20230 return resultobj;
20231 fail:
20232 return NULL;
20233 }
20234
20235
20236 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20237 PyObject *resultobj;
20238 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20239 bool result;
20240 PyObject * obj0 = 0 ;
20241 char *kwnames[] = {
20242 (char *) "self", NULL
20243 };
20244
20245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20247 if (SWIG_arg_fail(1)) SWIG_fail;
20248 {
20249 PyThreadState* __tstate = wxPyBeginAllowThreads();
20250 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20251
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 {
20256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20257 }
20258 return resultobj;
20259 fail:
20260 return NULL;
20261 }
20262
20263
20264 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20265 PyObject *resultobj;
20266 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20267 bool arg2 = (bool) true ;
20268 PyObject * obj0 = 0 ;
20269 PyObject * obj1 = 0 ;
20270 char *kwnames[] = {
20271 (char *) "self",(char *) "veto", NULL
20272 };
20273
20274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20276 if (SWIG_arg_fail(1)) SWIG_fail;
20277 if (obj1) {
20278 {
20279 arg2 = (bool)(SWIG_As_bool(obj1));
20280 if (SWIG_arg_fail(2)) SWIG_fail;
20281 }
20282 }
20283 {
20284 PyThreadState* __tstate = wxPyBeginAllowThreads();
20285 (arg1)->Veto(arg2);
20286
20287 wxPyEndAllowThreads(__tstate);
20288 if (PyErr_Occurred()) SWIG_fail;
20289 }
20290 Py_INCREF(Py_None); resultobj = Py_None;
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20298 PyObject *resultobj;
20299 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20300 bool arg2 ;
20301 PyObject * obj0 = 0 ;
20302 PyObject * obj1 = 0 ;
20303 char *kwnames[] = {
20304 (char *) "self",(char *) "canVeto", NULL
20305 };
20306
20307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20309 if (SWIG_arg_fail(1)) SWIG_fail;
20310 {
20311 arg2 = (bool)(SWIG_As_bool(obj1));
20312 if (SWIG_arg_fail(2)) SWIG_fail;
20313 }
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 (arg1)->SetCanVeto(arg2);
20317
20318 wxPyEndAllowThreads(__tstate);
20319 if (PyErr_Occurred()) SWIG_fail;
20320 }
20321 Py_INCREF(Py_None); resultobj = Py_None;
20322 return resultobj;
20323 fail:
20324 return NULL;
20325 }
20326
20327
20328 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20329 PyObject *resultobj;
20330 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20331 bool result;
20332 PyObject * obj0 = 0 ;
20333 char *kwnames[] = {
20334 (char *) "self", NULL
20335 };
20336
20337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20339 if (SWIG_arg_fail(1)) SWIG_fail;
20340 {
20341 PyThreadState* __tstate = wxPyBeginAllowThreads();
20342 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20343
20344 wxPyEndAllowThreads(__tstate);
20345 if (PyErr_Occurred()) SWIG_fail;
20346 }
20347 {
20348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20349 }
20350 return resultobj;
20351 fail:
20352 return NULL;
20353 }
20354
20355
20356 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20357 PyObject *resultobj;
20358 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20359 bool result;
20360 PyObject * obj0 = 0 ;
20361 char *kwnames[] = {
20362 (char *) "self", NULL
20363 };
20364
20365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20367 if (SWIG_arg_fail(1)) SWIG_fail;
20368 {
20369 PyThreadState* __tstate = wxPyBeginAllowThreads();
20370 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20371
20372 wxPyEndAllowThreads(__tstate);
20373 if (PyErr_Occurred()) SWIG_fail;
20374 }
20375 {
20376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20377 }
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20385 PyObject *obj;
20386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20387 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20388 Py_INCREF(obj);
20389 return Py_BuildValue((char *)"");
20390 }
20391 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20392 PyObject *resultobj;
20393 int arg1 = (int) 0 ;
20394 bool arg2 = (bool) false ;
20395 wxShowEvent *result;
20396 PyObject * obj0 = 0 ;
20397 PyObject * obj1 = 0 ;
20398 char *kwnames[] = {
20399 (char *) "winid",(char *) "show", NULL
20400 };
20401
20402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20403 if (obj0) {
20404 {
20405 arg1 = (int)(SWIG_As_int(obj0));
20406 if (SWIG_arg_fail(1)) SWIG_fail;
20407 }
20408 }
20409 if (obj1) {
20410 {
20411 arg2 = (bool)(SWIG_As_bool(obj1));
20412 if (SWIG_arg_fail(2)) SWIG_fail;
20413 }
20414 }
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20418
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20423 return resultobj;
20424 fail:
20425 return NULL;
20426 }
20427
20428
20429 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20430 PyObject *resultobj;
20431 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20432 bool arg2 ;
20433 PyObject * obj0 = 0 ;
20434 PyObject * obj1 = 0 ;
20435 char *kwnames[] = {
20436 (char *) "self",(char *) "show", NULL
20437 };
20438
20439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20441 if (SWIG_arg_fail(1)) SWIG_fail;
20442 {
20443 arg2 = (bool)(SWIG_As_bool(obj1));
20444 if (SWIG_arg_fail(2)) SWIG_fail;
20445 }
20446 {
20447 PyThreadState* __tstate = wxPyBeginAllowThreads();
20448 (arg1)->SetShow(arg2);
20449
20450 wxPyEndAllowThreads(__tstate);
20451 if (PyErr_Occurred()) SWIG_fail;
20452 }
20453 Py_INCREF(Py_None); resultobj = Py_None;
20454 return resultobj;
20455 fail:
20456 return NULL;
20457 }
20458
20459
20460 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20461 PyObject *resultobj;
20462 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20463 bool result;
20464 PyObject * obj0 = 0 ;
20465 char *kwnames[] = {
20466 (char *) "self", NULL
20467 };
20468
20469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20471 if (SWIG_arg_fail(1)) SWIG_fail;
20472 {
20473 PyThreadState* __tstate = wxPyBeginAllowThreads();
20474 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20475
20476 wxPyEndAllowThreads(__tstate);
20477 if (PyErr_Occurred()) SWIG_fail;
20478 }
20479 {
20480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20481 }
20482 return resultobj;
20483 fail:
20484 return NULL;
20485 }
20486
20487
20488 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20489 PyObject *obj;
20490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20491 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20492 Py_INCREF(obj);
20493 return Py_BuildValue((char *)"");
20494 }
20495 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20496 PyObject *resultobj;
20497 int arg1 = (int) 0 ;
20498 bool arg2 = (bool) true ;
20499 wxIconizeEvent *result;
20500 PyObject * obj0 = 0 ;
20501 PyObject * obj1 = 0 ;
20502 char *kwnames[] = {
20503 (char *) "id",(char *) "iconized", NULL
20504 };
20505
20506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20507 if (obj0) {
20508 {
20509 arg1 = (int)(SWIG_As_int(obj0));
20510 if (SWIG_arg_fail(1)) SWIG_fail;
20511 }
20512 }
20513 if (obj1) {
20514 {
20515 arg2 = (bool)(SWIG_As_bool(obj1));
20516 if (SWIG_arg_fail(2)) SWIG_fail;
20517 }
20518 }
20519 {
20520 PyThreadState* __tstate = wxPyBeginAllowThreads();
20521 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20522
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20527 return resultobj;
20528 fail:
20529 return NULL;
20530 }
20531
20532
20533 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20534 PyObject *resultobj;
20535 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20536 bool result;
20537 PyObject * obj0 = 0 ;
20538 char *kwnames[] = {
20539 (char *) "self", NULL
20540 };
20541
20542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20544 if (SWIG_arg_fail(1)) SWIG_fail;
20545 {
20546 PyThreadState* __tstate = wxPyBeginAllowThreads();
20547 result = (bool)(arg1)->Iconized();
20548
20549 wxPyEndAllowThreads(__tstate);
20550 if (PyErr_Occurred()) SWIG_fail;
20551 }
20552 {
20553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20554 }
20555 return resultobj;
20556 fail:
20557 return NULL;
20558 }
20559
20560
20561 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20562 PyObject *obj;
20563 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20564 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20565 Py_INCREF(obj);
20566 return Py_BuildValue((char *)"");
20567 }
20568 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20569 PyObject *resultobj;
20570 int arg1 = (int) 0 ;
20571 wxMaximizeEvent *result;
20572 PyObject * obj0 = 0 ;
20573 char *kwnames[] = {
20574 (char *) "id", NULL
20575 };
20576
20577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20578 if (obj0) {
20579 {
20580 arg1 = (int)(SWIG_As_int(obj0));
20581 if (SWIG_arg_fail(1)) SWIG_fail;
20582 }
20583 }
20584 {
20585 PyThreadState* __tstate = wxPyBeginAllowThreads();
20586 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20587
20588 wxPyEndAllowThreads(__tstate);
20589 if (PyErr_Occurred()) SWIG_fail;
20590 }
20591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20592 return resultobj;
20593 fail:
20594 return NULL;
20595 }
20596
20597
20598 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20599 PyObject *obj;
20600 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20601 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20602 Py_INCREF(obj);
20603 return Py_BuildValue((char *)"");
20604 }
20605 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20606 PyObject *resultobj;
20607 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20608 wxPoint result;
20609 PyObject * obj0 = 0 ;
20610 char *kwnames[] = {
20611 (char *) "self", NULL
20612 };
20613
20614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20616 if (SWIG_arg_fail(1)) SWIG_fail;
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 result = (arg1)->GetPosition();
20620
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 wxPoint * resultptr;
20626 resultptr = new wxPoint((wxPoint &)(result));
20627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20628 }
20629 return resultobj;
20630 fail:
20631 return NULL;
20632 }
20633
20634
20635 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20636 PyObject *resultobj;
20637 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20638 int result;
20639 PyObject * obj0 = 0 ;
20640 char *kwnames[] = {
20641 (char *) "self", NULL
20642 };
20643
20644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20646 if (SWIG_arg_fail(1)) SWIG_fail;
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 result = (int)(arg1)->GetNumberOfFiles();
20650
20651 wxPyEndAllowThreads(__tstate);
20652 if (PyErr_Occurred()) SWIG_fail;
20653 }
20654 {
20655 resultobj = SWIG_From_int((int)(result));
20656 }
20657 return resultobj;
20658 fail:
20659 return NULL;
20660 }
20661
20662
20663 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20664 PyObject *resultobj;
20665 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20666 PyObject *result;
20667 PyObject * obj0 = 0 ;
20668 char *kwnames[] = {
20669 (char *) "self", NULL
20670 };
20671
20672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20674 if (SWIG_arg_fail(1)) SWIG_fail;
20675 {
20676 PyThreadState* __tstate = wxPyBeginAllowThreads();
20677 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20678
20679 wxPyEndAllowThreads(__tstate);
20680 if (PyErr_Occurred()) SWIG_fail;
20681 }
20682 resultobj = result;
20683 return resultobj;
20684 fail:
20685 return NULL;
20686 }
20687
20688
20689 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20690 PyObject *obj;
20691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20692 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20693 Py_INCREF(obj);
20694 return Py_BuildValue((char *)"");
20695 }
20696 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20697 PyObject *resultobj;
20698 int arg1 = (int) 0 ;
20699 wxUpdateUIEvent *result;
20700 PyObject * obj0 = 0 ;
20701 char *kwnames[] = {
20702 (char *) "commandId", NULL
20703 };
20704
20705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20706 if (obj0) {
20707 {
20708 arg1 = (int)(SWIG_As_int(obj0));
20709 if (SWIG_arg_fail(1)) SWIG_fail;
20710 }
20711 }
20712 {
20713 PyThreadState* __tstate = wxPyBeginAllowThreads();
20714 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20715
20716 wxPyEndAllowThreads(__tstate);
20717 if (PyErr_Occurred()) SWIG_fail;
20718 }
20719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20727 PyObject *resultobj;
20728 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20729 bool result;
20730 PyObject * obj0 = 0 ;
20731 char *kwnames[] = {
20732 (char *) "self", NULL
20733 };
20734
20735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20737 if (SWIG_arg_fail(1)) SWIG_fail;
20738 {
20739 PyThreadState* __tstate = wxPyBeginAllowThreads();
20740 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20741
20742 wxPyEndAllowThreads(__tstate);
20743 if (PyErr_Occurred()) SWIG_fail;
20744 }
20745 {
20746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20747 }
20748 return resultobj;
20749 fail:
20750 return NULL;
20751 }
20752
20753
20754 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20755 PyObject *resultobj;
20756 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20757 bool result;
20758 PyObject * obj0 = 0 ;
20759 char *kwnames[] = {
20760 (char *) "self", NULL
20761 };
20762
20763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20765 if (SWIG_arg_fail(1)) SWIG_fail;
20766 {
20767 PyThreadState* __tstate = wxPyBeginAllowThreads();
20768 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20769
20770 wxPyEndAllowThreads(__tstate);
20771 if (PyErr_Occurred()) SWIG_fail;
20772 }
20773 {
20774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20775 }
20776 return resultobj;
20777 fail:
20778 return NULL;
20779 }
20780
20781
20782 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20783 PyObject *resultobj;
20784 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20785 wxString result;
20786 PyObject * obj0 = 0 ;
20787 char *kwnames[] = {
20788 (char *) "self", NULL
20789 };
20790
20791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20793 if (SWIG_arg_fail(1)) SWIG_fail;
20794 {
20795 PyThreadState* __tstate = wxPyBeginAllowThreads();
20796 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20797
20798 wxPyEndAllowThreads(__tstate);
20799 if (PyErr_Occurred()) SWIG_fail;
20800 }
20801 {
20802 #if wxUSE_UNICODE
20803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20804 #else
20805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20806 #endif
20807 }
20808 return resultobj;
20809 fail:
20810 return NULL;
20811 }
20812
20813
20814 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20815 PyObject *resultobj;
20816 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20817 bool result;
20818 PyObject * obj0 = 0 ;
20819 char *kwnames[] = {
20820 (char *) "self", NULL
20821 };
20822
20823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20825 if (SWIG_arg_fail(1)) SWIG_fail;
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20829
20830 wxPyEndAllowThreads(__tstate);
20831 if (PyErr_Occurred()) SWIG_fail;
20832 }
20833 {
20834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20835 }
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20843 PyObject *resultobj;
20844 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20845 bool result;
20846 PyObject * obj0 = 0 ;
20847 char *kwnames[] = {
20848 (char *) "self", NULL
20849 };
20850
20851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20853 if (SWIG_arg_fail(1)) SWIG_fail;
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20857
20858 wxPyEndAllowThreads(__tstate);
20859 if (PyErr_Occurred()) SWIG_fail;
20860 }
20861 {
20862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20863 }
20864 return resultobj;
20865 fail:
20866 return NULL;
20867 }
20868
20869
20870 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20871 PyObject *resultobj;
20872 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20873 bool result;
20874 PyObject * obj0 = 0 ;
20875 char *kwnames[] = {
20876 (char *) "self", NULL
20877 };
20878
20879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20881 if (SWIG_arg_fail(1)) SWIG_fail;
20882 {
20883 PyThreadState* __tstate = wxPyBeginAllowThreads();
20884 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20885
20886 wxPyEndAllowThreads(__tstate);
20887 if (PyErr_Occurred()) SWIG_fail;
20888 }
20889 {
20890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20891 }
20892 return resultobj;
20893 fail:
20894 return NULL;
20895 }
20896
20897
20898 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20899 PyObject *resultobj;
20900 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20901 bool arg2 ;
20902 PyObject * obj0 = 0 ;
20903 PyObject * obj1 = 0 ;
20904 char *kwnames[] = {
20905 (char *) "self",(char *) "check", NULL
20906 };
20907
20908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20910 if (SWIG_arg_fail(1)) SWIG_fail;
20911 {
20912 arg2 = (bool)(SWIG_As_bool(obj1));
20913 if (SWIG_arg_fail(2)) SWIG_fail;
20914 }
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 (arg1)->Check(arg2);
20918
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 Py_INCREF(Py_None); resultobj = Py_None;
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20930 PyObject *resultobj;
20931 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20932 bool arg2 ;
20933 PyObject * obj0 = 0 ;
20934 PyObject * obj1 = 0 ;
20935 char *kwnames[] = {
20936 (char *) "self",(char *) "enable", NULL
20937 };
20938
20939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20941 if (SWIG_arg_fail(1)) SWIG_fail;
20942 {
20943 arg2 = (bool)(SWIG_As_bool(obj1));
20944 if (SWIG_arg_fail(2)) SWIG_fail;
20945 }
20946 {
20947 PyThreadState* __tstate = wxPyBeginAllowThreads();
20948 (arg1)->Enable(arg2);
20949
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 Py_INCREF(Py_None); resultobj = Py_None;
20954 return resultobj;
20955 fail:
20956 return NULL;
20957 }
20958
20959
20960 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20961 PyObject *resultobj;
20962 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20963 wxString *arg2 = 0 ;
20964 bool temp2 = false ;
20965 PyObject * obj0 = 0 ;
20966 PyObject * obj1 = 0 ;
20967 char *kwnames[] = {
20968 (char *) "self",(char *) "text", NULL
20969 };
20970
20971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20973 if (SWIG_arg_fail(1)) SWIG_fail;
20974 {
20975 arg2 = wxString_in_helper(obj1);
20976 if (arg2 == NULL) SWIG_fail;
20977 temp2 = true;
20978 }
20979 {
20980 PyThreadState* __tstate = wxPyBeginAllowThreads();
20981 (arg1)->SetText((wxString const &)*arg2);
20982
20983 wxPyEndAllowThreads(__tstate);
20984 if (PyErr_Occurred()) SWIG_fail;
20985 }
20986 Py_INCREF(Py_None); resultobj = Py_None;
20987 {
20988 if (temp2)
20989 delete arg2;
20990 }
20991 return resultobj;
20992 fail:
20993 {
20994 if (temp2)
20995 delete arg2;
20996 }
20997 return NULL;
20998 }
20999
21000
21001 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21002 PyObject *resultobj;
21003 long arg1 ;
21004 PyObject * obj0 = 0 ;
21005 char *kwnames[] = {
21006 (char *) "updateInterval", NULL
21007 };
21008
21009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21010 {
21011 arg1 = (long)(SWIG_As_long(obj0));
21012 if (SWIG_arg_fail(1)) SWIG_fail;
21013 }
21014 {
21015 PyThreadState* __tstate = wxPyBeginAllowThreads();
21016 wxUpdateUIEvent::SetUpdateInterval(arg1);
21017
21018 wxPyEndAllowThreads(__tstate);
21019 if (PyErr_Occurred()) SWIG_fail;
21020 }
21021 Py_INCREF(Py_None); resultobj = Py_None;
21022 return resultobj;
21023 fail:
21024 return NULL;
21025 }
21026
21027
21028 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21029 PyObject *resultobj;
21030 long result;
21031 char *kwnames[] = {
21032 NULL
21033 };
21034
21035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21039
21040 wxPyEndAllowThreads(__tstate);
21041 if (PyErr_Occurred()) SWIG_fail;
21042 }
21043 {
21044 resultobj = SWIG_From_long((long)(result));
21045 }
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21053 PyObject *resultobj;
21054 wxWindow *arg1 = (wxWindow *) 0 ;
21055 bool result;
21056 PyObject * obj0 = 0 ;
21057 char *kwnames[] = {
21058 (char *) "win", NULL
21059 };
21060
21061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21063 if (SWIG_arg_fail(1)) SWIG_fail;
21064 {
21065 PyThreadState* __tstate = wxPyBeginAllowThreads();
21066 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21067
21068 wxPyEndAllowThreads(__tstate);
21069 if (PyErr_Occurred()) SWIG_fail;
21070 }
21071 {
21072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21073 }
21074 return resultobj;
21075 fail:
21076 return NULL;
21077 }
21078
21079
21080 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21081 PyObject *resultobj;
21082 char *kwnames[] = {
21083 NULL
21084 };
21085
21086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21087 {
21088 PyThreadState* __tstate = wxPyBeginAllowThreads();
21089 wxUpdateUIEvent::ResetUpdateTime();
21090
21091 wxPyEndAllowThreads(__tstate);
21092 if (PyErr_Occurred()) SWIG_fail;
21093 }
21094 Py_INCREF(Py_None); resultobj = Py_None;
21095 return resultobj;
21096 fail:
21097 return NULL;
21098 }
21099
21100
21101 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21102 PyObject *resultobj;
21103 wxUpdateUIMode arg1 ;
21104 PyObject * obj0 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "mode", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21110 {
21111 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21112 if (SWIG_arg_fail(1)) SWIG_fail;
21113 }
21114 {
21115 PyThreadState* __tstate = wxPyBeginAllowThreads();
21116 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21117
21118 wxPyEndAllowThreads(__tstate);
21119 if (PyErr_Occurred()) SWIG_fail;
21120 }
21121 Py_INCREF(Py_None); resultobj = Py_None;
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21129 PyObject *resultobj;
21130 wxUpdateUIMode result;
21131 char *kwnames[] = {
21132 NULL
21133 };
21134
21135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21136 {
21137 PyThreadState* __tstate = wxPyBeginAllowThreads();
21138 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21139
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 resultobj = SWIG_From_int((result));
21144 return resultobj;
21145 fail:
21146 return NULL;
21147 }
21148
21149
21150 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21151 PyObject *obj;
21152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21153 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21154 Py_INCREF(obj);
21155 return Py_BuildValue((char *)"");
21156 }
21157 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21158 PyObject *resultobj;
21159 wxSysColourChangedEvent *result;
21160 char *kwnames[] = {
21161 NULL
21162 };
21163
21164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21165 {
21166 PyThreadState* __tstate = wxPyBeginAllowThreads();
21167 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21168
21169 wxPyEndAllowThreads(__tstate);
21170 if (PyErr_Occurred()) SWIG_fail;
21171 }
21172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21173 return resultobj;
21174 fail:
21175 return NULL;
21176 }
21177
21178
21179 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21180 PyObject *obj;
21181 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21182 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21183 Py_INCREF(obj);
21184 return Py_BuildValue((char *)"");
21185 }
21186 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21187 PyObject *resultobj;
21188 int arg1 = (int) 0 ;
21189 wxWindow *arg2 = (wxWindow *) NULL ;
21190 wxMouseCaptureChangedEvent *result;
21191 PyObject * obj0 = 0 ;
21192 PyObject * obj1 = 0 ;
21193 char *kwnames[] = {
21194 (char *) "winid",(char *) "gainedCapture", NULL
21195 };
21196
21197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21198 if (obj0) {
21199 {
21200 arg1 = (int)(SWIG_As_int(obj0));
21201 if (SWIG_arg_fail(1)) SWIG_fail;
21202 }
21203 }
21204 if (obj1) {
21205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21206 if (SWIG_arg_fail(2)) SWIG_fail;
21207 }
21208 {
21209 PyThreadState* __tstate = wxPyBeginAllowThreads();
21210 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21211
21212 wxPyEndAllowThreads(__tstate);
21213 if (PyErr_Occurred()) SWIG_fail;
21214 }
21215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21216 return resultobj;
21217 fail:
21218 return NULL;
21219 }
21220
21221
21222 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21223 PyObject *resultobj;
21224 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21225 wxWindow *result;
21226 PyObject * obj0 = 0 ;
21227 char *kwnames[] = {
21228 (char *) "self", NULL
21229 };
21230
21231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21233 if (SWIG_arg_fail(1)) SWIG_fail;
21234 {
21235 PyThreadState* __tstate = wxPyBeginAllowThreads();
21236 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21237
21238 wxPyEndAllowThreads(__tstate);
21239 if (PyErr_Occurred()) SWIG_fail;
21240 }
21241 {
21242 resultobj = wxPyMake_wxObject(result, 0);
21243 }
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21251 PyObject *obj;
21252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21253 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21254 Py_INCREF(obj);
21255 return Py_BuildValue((char *)"");
21256 }
21257 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21258 PyObject *resultobj;
21259 wxDisplayChangedEvent *result;
21260 char *kwnames[] = {
21261 NULL
21262 };
21263
21264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21265 {
21266 PyThreadState* __tstate = wxPyBeginAllowThreads();
21267 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21268
21269 wxPyEndAllowThreads(__tstate);
21270 if (PyErr_Occurred()) SWIG_fail;
21271 }
21272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21280 PyObject *obj;
21281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21282 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21283 Py_INCREF(obj);
21284 return Py_BuildValue((char *)"");
21285 }
21286 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21287 PyObject *resultobj;
21288 int arg1 = (int) 0 ;
21289 wxPaletteChangedEvent *result;
21290 PyObject * obj0 = 0 ;
21291 char *kwnames[] = {
21292 (char *) "id", NULL
21293 };
21294
21295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21296 if (obj0) {
21297 {
21298 arg1 = (int)(SWIG_As_int(obj0));
21299 if (SWIG_arg_fail(1)) SWIG_fail;
21300 }
21301 }
21302 {
21303 PyThreadState* __tstate = wxPyBeginAllowThreads();
21304 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21305
21306 wxPyEndAllowThreads(__tstate);
21307 if (PyErr_Occurred()) SWIG_fail;
21308 }
21309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21310 return resultobj;
21311 fail:
21312 return NULL;
21313 }
21314
21315
21316 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21317 PyObject *resultobj;
21318 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21319 wxWindow *arg2 = (wxWindow *) 0 ;
21320 PyObject * obj0 = 0 ;
21321 PyObject * obj1 = 0 ;
21322 char *kwnames[] = {
21323 (char *) "self",(char *) "win", NULL
21324 };
21325
21326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21328 if (SWIG_arg_fail(1)) SWIG_fail;
21329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21330 if (SWIG_arg_fail(2)) SWIG_fail;
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 (arg1)->SetChangedWindow(arg2);
21334
21335 wxPyEndAllowThreads(__tstate);
21336 if (PyErr_Occurred()) SWIG_fail;
21337 }
21338 Py_INCREF(Py_None); resultobj = Py_None;
21339 return resultobj;
21340 fail:
21341 return NULL;
21342 }
21343
21344
21345 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21346 PyObject *resultobj;
21347 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21348 wxWindow *result;
21349 PyObject * obj0 = 0 ;
21350 char *kwnames[] = {
21351 (char *) "self", NULL
21352 };
21353
21354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21356 if (SWIG_arg_fail(1)) SWIG_fail;
21357 {
21358 PyThreadState* __tstate = wxPyBeginAllowThreads();
21359 result = (wxWindow *)(arg1)->GetChangedWindow();
21360
21361 wxPyEndAllowThreads(__tstate);
21362 if (PyErr_Occurred()) SWIG_fail;
21363 }
21364 {
21365 resultobj = wxPyMake_wxObject(result, 0);
21366 }
21367 return resultobj;
21368 fail:
21369 return NULL;
21370 }
21371
21372
21373 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21374 PyObject *obj;
21375 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21376 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21377 Py_INCREF(obj);
21378 return Py_BuildValue((char *)"");
21379 }
21380 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21381 PyObject *resultobj;
21382 int arg1 = (int) 0 ;
21383 wxQueryNewPaletteEvent *result;
21384 PyObject * obj0 = 0 ;
21385 char *kwnames[] = {
21386 (char *) "winid", NULL
21387 };
21388
21389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21390 if (obj0) {
21391 {
21392 arg1 = (int)(SWIG_As_int(obj0));
21393 if (SWIG_arg_fail(1)) SWIG_fail;
21394 }
21395 }
21396 {
21397 PyThreadState* __tstate = wxPyBeginAllowThreads();
21398 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21399
21400 wxPyEndAllowThreads(__tstate);
21401 if (PyErr_Occurred()) SWIG_fail;
21402 }
21403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21404 return resultobj;
21405 fail:
21406 return NULL;
21407 }
21408
21409
21410 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21411 PyObject *resultobj;
21412 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21413 bool arg2 ;
21414 PyObject * obj0 = 0 ;
21415 PyObject * obj1 = 0 ;
21416 char *kwnames[] = {
21417 (char *) "self",(char *) "realized", NULL
21418 };
21419
21420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21422 if (SWIG_arg_fail(1)) SWIG_fail;
21423 {
21424 arg2 = (bool)(SWIG_As_bool(obj1));
21425 if (SWIG_arg_fail(2)) SWIG_fail;
21426 }
21427 {
21428 PyThreadState* __tstate = wxPyBeginAllowThreads();
21429 (arg1)->SetPaletteRealized(arg2);
21430
21431 wxPyEndAllowThreads(__tstate);
21432 if (PyErr_Occurred()) SWIG_fail;
21433 }
21434 Py_INCREF(Py_None); resultobj = Py_None;
21435 return resultobj;
21436 fail:
21437 return NULL;
21438 }
21439
21440
21441 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21442 PyObject *resultobj;
21443 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21444 bool result;
21445 PyObject * obj0 = 0 ;
21446 char *kwnames[] = {
21447 (char *) "self", NULL
21448 };
21449
21450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21452 if (SWIG_arg_fail(1)) SWIG_fail;
21453 {
21454 PyThreadState* __tstate = wxPyBeginAllowThreads();
21455 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21456
21457 wxPyEndAllowThreads(__tstate);
21458 if (PyErr_Occurred()) SWIG_fail;
21459 }
21460 {
21461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21462 }
21463 return resultobj;
21464 fail:
21465 return NULL;
21466 }
21467
21468
21469 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21470 PyObject *obj;
21471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21472 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21473 Py_INCREF(obj);
21474 return Py_BuildValue((char *)"");
21475 }
21476 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21477 PyObject *resultobj;
21478 wxNavigationKeyEvent *result;
21479 char *kwnames[] = {
21480 NULL
21481 };
21482
21483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21484 {
21485 PyThreadState* __tstate = wxPyBeginAllowThreads();
21486 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21487
21488 wxPyEndAllowThreads(__tstate);
21489 if (PyErr_Occurred()) SWIG_fail;
21490 }
21491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21492 return resultobj;
21493 fail:
21494 return NULL;
21495 }
21496
21497
21498 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21499 PyObject *resultobj;
21500 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21501 bool result;
21502 PyObject * obj0 = 0 ;
21503 char *kwnames[] = {
21504 (char *) "self", NULL
21505 };
21506
21507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21509 if (SWIG_arg_fail(1)) SWIG_fail;
21510 {
21511 PyThreadState* __tstate = wxPyBeginAllowThreads();
21512 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21513
21514 wxPyEndAllowThreads(__tstate);
21515 if (PyErr_Occurred()) SWIG_fail;
21516 }
21517 {
21518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21519 }
21520 return resultobj;
21521 fail:
21522 return NULL;
21523 }
21524
21525
21526 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21527 PyObject *resultobj;
21528 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21529 bool arg2 ;
21530 PyObject * obj0 = 0 ;
21531 PyObject * obj1 = 0 ;
21532 char *kwnames[] = {
21533 (char *) "self",(char *) "forward", NULL
21534 };
21535
21536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21538 if (SWIG_arg_fail(1)) SWIG_fail;
21539 {
21540 arg2 = (bool)(SWIG_As_bool(obj1));
21541 if (SWIG_arg_fail(2)) SWIG_fail;
21542 }
21543 {
21544 PyThreadState* __tstate = wxPyBeginAllowThreads();
21545 (arg1)->SetDirection(arg2);
21546
21547 wxPyEndAllowThreads(__tstate);
21548 if (PyErr_Occurred()) SWIG_fail;
21549 }
21550 Py_INCREF(Py_None); resultobj = Py_None;
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21558 PyObject *resultobj;
21559 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21560 bool result;
21561 PyObject * obj0 = 0 ;
21562 char *kwnames[] = {
21563 (char *) "self", NULL
21564 };
21565
21566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21568 if (SWIG_arg_fail(1)) SWIG_fail;
21569 {
21570 PyThreadState* __tstate = wxPyBeginAllowThreads();
21571 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21572
21573 wxPyEndAllowThreads(__tstate);
21574 if (PyErr_Occurred()) SWIG_fail;
21575 }
21576 {
21577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21578 }
21579 return resultobj;
21580 fail:
21581 return NULL;
21582 }
21583
21584
21585 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21586 PyObject *resultobj;
21587 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21588 bool arg2 ;
21589 PyObject * obj0 = 0 ;
21590 PyObject * obj1 = 0 ;
21591 char *kwnames[] = {
21592 (char *) "self",(char *) "ischange", NULL
21593 };
21594
21595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21597 if (SWIG_arg_fail(1)) SWIG_fail;
21598 {
21599 arg2 = (bool)(SWIG_As_bool(obj1));
21600 if (SWIG_arg_fail(2)) SWIG_fail;
21601 }
21602 {
21603 PyThreadState* __tstate = wxPyBeginAllowThreads();
21604 (arg1)->SetWindowChange(arg2);
21605
21606 wxPyEndAllowThreads(__tstate);
21607 if (PyErr_Occurred()) SWIG_fail;
21608 }
21609 Py_INCREF(Py_None); resultobj = Py_None;
21610 return resultobj;
21611 fail:
21612 return NULL;
21613 }
21614
21615
21616 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21617 PyObject *resultobj;
21618 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21619 bool result;
21620 PyObject * obj0 = 0 ;
21621 char *kwnames[] = {
21622 (char *) "self", NULL
21623 };
21624
21625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21627 if (SWIG_arg_fail(1)) SWIG_fail;
21628 {
21629 PyThreadState* __tstate = wxPyBeginAllowThreads();
21630 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21631
21632 wxPyEndAllowThreads(__tstate);
21633 if (PyErr_Occurred()) SWIG_fail;
21634 }
21635 {
21636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21637 }
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj;
21646 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21647 bool arg2 ;
21648 PyObject * obj0 = 0 ;
21649 PyObject * obj1 = 0 ;
21650 char *kwnames[] = {
21651 (char *) "self",(char *) "bIs", NULL
21652 };
21653
21654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21656 if (SWIG_arg_fail(1)) SWIG_fail;
21657 {
21658 arg2 = (bool)(SWIG_As_bool(obj1));
21659 if (SWIG_arg_fail(2)) SWIG_fail;
21660 }
21661 {
21662 PyThreadState* __tstate = wxPyBeginAllowThreads();
21663 (arg1)->SetFromTab(arg2);
21664
21665 wxPyEndAllowThreads(__tstate);
21666 if (PyErr_Occurred()) SWIG_fail;
21667 }
21668 Py_INCREF(Py_None); resultobj = Py_None;
21669 return resultobj;
21670 fail:
21671 return NULL;
21672 }
21673
21674
21675 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21676 PyObject *resultobj;
21677 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21678 long arg2 ;
21679 PyObject * obj0 = 0 ;
21680 PyObject * obj1 = 0 ;
21681 char *kwnames[] = {
21682 (char *) "self",(char *) "flags", NULL
21683 };
21684
21685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21687 if (SWIG_arg_fail(1)) SWIG_fail;
21688 {
21689 arg2 = (long)(SWIG_As_long(obj1));
21690 if (SWIG_arg_fail(2)) SWIG_fail;
21691 }
21692 {
21693 PyThreadState* __tstate = wxPyBeginAllowThreads();
21694 (arg1)->SetFlags(arg2);
21695
21696 wxPyEndAllowThreads(__tstate);
21697 if (PyErr_Occurred()) SWIG_fail;
21698 }
21699 Py_INCREF(Py_None); resultobj = Py_None;
21700 return resultobj;
21701 fail:
21702 return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21707 PyObject *resultobj;
21708 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21709 wxWindow *result;
21710 PyObject * obj0 = 0 ;
21711 char *kwnames[] = {
21712 (char *) "self", NULL
21713 };
21714
21715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21717 if (SWIG_arg_fail(1)) SWIG_fail;
21718 {
21719 PyThreadState* __tstate = wxPyBeginAllowThreads();
21720 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21721
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 {
21726 resultobj = wxPyMake_wxObject(result, 0);
21727 }
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21735 PyObject *resultobj;
21736 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21737 wxWindow *arg2 = (wxWindow *) 0 ;
21738 PyObject * obj0 = 0 ;
21739 PyObject * obj1 = 0 ;
21740 char *kwnames[] = {
21741 (char *) "self",(char *) "win", NULL
21742 };
21743
21744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21746 if (SWIG_arg_fail(1)) SWIG_fail;
21747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21748 if (SWIG_arg_fail(2)) SWIG_fail;
21749 {
21750 PyThreadState* __tstate = wxPyBeginAllowThreads();
21751 (arg1)->SetCurrentFocus(arg2);
21752
21753 wxPyEndAllowThreads(__tstate);
21754 if (PyErr_Occurred()) SWIG_fail;
21755 }
21756 Py_INCREF(Py_None); resultobj = Py_None;
21757 return resultobj;
21758 fail:
21759 return NULL;
21760 }
21761
21762
21763 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21764 PyObject *obj;
21765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21766 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21767 Py_INCREF(obj);
21768 return Py_BuildValue((char *)"");
21769 }
21770 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21771 PyObject *resultobj;
21772 wxWindow *arg1 = (wxWindow *) NULL ;
21773 wxWindowCreateEvent *result;
21774 PyObject * obj0 = 0 ;
21775 char *kwnames[] = {
21776 (char *) "win", NULL
21777 };
21778
21779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21780 if (obj0) {
21781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21782 if (SWIG_arg_fail(1)) SWIG_fail;
21783 }
21784 {
21785 PyThreadState* __tstate = wxPyBeginAllowThreads();
21786 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21787
21788 wxPyEndAllowThreads(__tstate);
21789 if (PyErr_Occurred()) SWIG_fail;
21790 }
21791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21792 return resultobj;
21793 fail:
21794 return NULL;
21795 }
21796
21797
21798 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21799 PyObject *resultobj;
21800 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21801 wxWindow *result;
21802 PyObject * obj0 = 0 ;
21803 char *kwnames[] = {
21804 (char *) "self", NULL
21805 };
21806
21807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21809 if (SWIG_arg_fail(1)) SWIG_fail;
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21813
21814 wxPyEndAllowThreads(__tstate);
21815 if (PyErr_Occurred()) SWIG_fail;
21816 }
21817 {
21818 resultobj = wxPyMake_wxObject(result, 0);
21819 }
21820 return resultobj;
21821 fail:
21822 return NULL;
21823 }
21824
21825
21826 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21827 PyObject *obj;
21828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21829 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21830 Py_INCREF(obj);
21831 return Py_BuildValue((char *)"");
21832 }
21833 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21834 PyObject *resultobj;
21835 wxWindow *arg1 = (wxWindow *) NULL ;
21836 wxWindowDestroyEvent *result;
21837 PyObject * obj0 = 0 ;
21838 char *kwnames[] = {
21839 (char *) "win", NULL
21840 };
21841
21842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21843 if (obj0) {
21844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21845 if (SWIG_arg_fail(1)) SWIG_fail;
21846 }
21847 {
21848 PyThreadState* __tstate = wxPyBeginAllowThreads();
21849 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21850
21851 wxPyEndAllowThreads(__tstate);
21852 if (PyErr_Occurred()) SWIG_fail;
21853 }
21854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21855 return resultobj;
21856 fail:
21857 return NULL;
21858 }
21859
21860
21861 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21862 PyObject *resultobj;
21863 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21864 wxWindow *result;
21865 PyObject * obj0 = 0 ;
21866 char *kwnames[] = {
21867 (char *) "self", NULL
21868 };
21869
21870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21872 if (SWIG_arg_fail(1)) SWIG_fail;
21873 {
21874 PyThreadState* __tstate = wxPyBeginAllowThreads();
21875 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21876
21877 wxPyEndAllowThreads(__tstate);
21878 if (PyErr_Occurred()) SWIG_fail;
21879 }
21880 {
21881 resultobj = wxPyMake_wxObject(result, 0);
21882 }
21883 return resultobj;
21884 fail:
21885 return NULL;
21886 }
21887
21888
21889 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21890 PyObject *obj;
21891 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21892 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21893 Py_INCREF(obj);
21894 return Py_BuildValue((char *)"");
21895 }
21896 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21897 PyObject *resultobj;
21898 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21899 int arg2 = (int) 0 ;
21900 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21901 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21902 wxContextMenuEvent *result;
21903 wxPoint temp3 ;
21904 PyObject * obj0 = 0 ;
21905 PyObject * obj1 = 0 ;
21906 PyObject * obj2 = 0 ;
21907 char *kwnames[] = {
21908 (char *) "type",(char *) "winid",(char *) "pt", NULL
21909 };
21910
21911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21912 if (obj0) {
21913 {
21914 arg1 = (wxEventType)(SWIG_As_int(obj0));
21915 if (SWIG_arg_fail(1)) SWIG_fail;
21916 }
21917 }
21918 if (obj1) {
21919 {
21920 arg2 = (int)(SWIG_As_int(obj1));
21921 if (SWIG_arg_fail(2)) SWIG_fail;
21922 }
21923 }
21924 if (obj2) {
21925 {
21926 arg3 = &temp3;
21927 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21928 }
21929 }
21930 {
21931 PyThreadState* __tstate = wxPyBeginAllowThreads();
21932 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21933
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21945 PyObject *resultobj;
21946 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21947 wxPoint *result;
21948 PyObject * obj0 = 0 ;
21949 char *kwnames[] = {
21950 (char *) "self", NULL
21951 };
21952
21953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21955 if (SWIG_arg_fail(1)) SWIG_fail;
21956 {
21957 PyThreadState* __tstate = wxPyBeginAllowThreads();
21958 {
21959 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21960 result = (wxPoint *) &_result_ref;
21961 }
21962
21963 wxPyEndAllowThreads(__tstate);
21964 if (PyErr_Occurred()) SWIG_fail;
21965 }
21966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21974 PyObject *resultobj;
21975 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21976 wxPoint *arg2 = 0 ;
21977 wxPoint temp2 ;
21978 PyObject * obj0 = 0 ;
21979 PyObject * obj1 = 0 ;
21980 char *kwnames[] = {
21981 (char *) "self",(char *) "pos", NULL
21982 };
21983
21984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21986 if (SWIG_arg_fail(1)) SWIG_fail;
21987 {
21988 arg2 = &temp2;
21989 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21990 }
21991 {
21992 PyThreadState* __tstate = wxPyBeginAllowThreads();
21993 (arg1)->SetPosition((wxPoint const &)*arg2);
21994
21995 wxPyEndAllowThreads(__tstate);
21996 if (PyErr_Occurred()) SWIG_fail;
21997 }
21998 Py_INCREF(Py_None); resultobj = Py_None;
21999 return resultobj;
22000 fail:
22001 return NULL;
22002 }
22003
22004
22005 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22006 PyObject *obj;
22007 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22008 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22009 Py_INCREF(obj);
22010 return Py_BuildValue((char *)"");
22011 }
22012 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22013 PyObject *resultobj;
22014 wxIdleEvent *result;
22015 char *kwnames[] = {
22016 NULL
22017 };
22018
22019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22020 {
22021 PyThreadState* __tstate = wxPyBeginAllowThreads();
22022 result = (wxIdleEvent *)new wxIdleEvent();
22023
22024 wxPyEndAllowThreads(__tstate);
22025 if (PyErr_Occurred()) SWIG_fail;
22026 }
22027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22028 return resultobj;
22029 fail:
22030 return NULL;
22031 }
22032
22033
22034 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22035 PyObject *resultobj;
22036 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22037 bool arg2 = (bool) true ;
22038 PyObject * obj0 = 0 ;
22039 PyObject * obj1 = 0 ;
22040 char *kwnames[] = {
22041 (char *) "self",(char *) "needMore", NULL
22042 };
22043
22044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22046 if (SWIG_arg_fail(1)) SWIG_fail;
22047 if (obj1) {
22048 {
22049 arg2 = (bool)(SWIG_As_bool(obj1));
22050 if (SWIG_arg_fail(2)) SWIG_fail;
22051 }
22052 }
22053 {
22054 PyThreadState* __tstate = wxPyBeginAllowThreads();
22055 (arg1)->RequestMore(arg2);
22056
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 Py_INCREF(Py_None); resultobj = Py_None;
22061 return resultobj;
22062 fail:
22063 return NULL;
22064 }
22065
22066
22067 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22068 PyObject *resultobj;
22069 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22070 bool result;
22071 PyObject * obj0 = 0 ;
22072 char *kwnames[] = {
22073 (char *) "self", NULL
22074 };
22075
22076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22078 if (SWIG_arg_fail(1)) SWIG_fail;
22079 {
22080 PyThreadState* __tstate = wxPyBeginAllowThreads();
22081 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22082
22083 wxPyEndAllowThreads(__tstate);
22084 if (PyErr_Occurred()) SWIG_fail;
22085 }
22086 {
22087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22088 }
22089 return resultobj;
22090 fail:
22091 return NULL;
22092 }
22093
22094
22095 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22096 PyObject *resultobj;
22097 wxIdleMode arg1 ;
22098 PyObject * obj0 = 0 ;
22099 char *kwnames[] = {
22100 (char *) "mode", NULL
22101 };
22102
22103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22104 {
22105 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22106 if (SWIG_arg_fail(1)) SWIG_fail;
22107 }
22108 {
22109 PyThreadState* __tstate = wxPyBeginAllowThreads();
22110 wxIdleEvent::SetMode((wxIdleMode )arg1);
22111
22112 wxPyEndAllowThreads(__tstate);
22113 if (PyErr_Occurred()) SWIG_fail;
22114 }
22115 Py_INCREF(Py_None); resultobj = Py_None;
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj;
22124 wxIdleMode result;
22125 char *kwnames[] = {
22126 NULL
22127 };
22128
22129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 result = (wxIdleMode)wxIdleEvent::GetMode();
22133
22134 wxPyEndAllowThreads(__tstate);
22135 if (PyErr_Occurred()) SWIG_fail;
22136 }
22137 resultobj = SWIG_From_int((result));
22138 return resultobj;
22139 fail:
22140 return NULL;
22141 }
22142
22143
22144 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22145 PyObject *resultobj;
22146 wxWindow *arg1 = (wxWindow *) 0 ;
22147 bool result;
22148 PyObject * obj0 = 0 ;
22149 char *kwnames[] = {
22150 (char *) "win", NULL
22151 };
22152
22153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22155 if (SWIG_arg_fail(1)) SWIG_fail;
22156 {
22157 PyThreadState* __tstate = wxPyBeginAllowThreads();
22158 result = (bool)wxIdleEvent::CanSend(arg1);
22159
22160 wxPyEndAllowThreads(__tstate);
22161 if (PyErr_Occurred()) SWIG_fail;
22162 }
22163 {
22164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22165 }
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22173 PyObject *obj;
22174 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22175 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22176 Py_INCREF(obj);
22177 return Py_BuildValue((char *)"");
22178 }
22179 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22180 PyObject *resultobj;
22181 int arg1 = (int) 0 ;
22182 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22183 wxPyEvent *result;
22184 PyObject * obj0 = 0 ;
22185 PyObject * obj1 = 0 ;
22186 char *kwnames[] = {
22187 (char *) "winid",(char *) "commandType", NULL
22188 };
22189
22190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22191 if (obj0) {
22192 {
22193 arg1 = (int)(SWIG_As_int(obj0));
22194 if (SWIG_arg_fail(1)) SWIG_fail;
22195 }
22196 }
22197 if (obj1) {
22198 {
22199 arg2 = (wxEventType)(SWIG_As_int(obj1));
22200 if (SWIG_arg_fail(2)) SWIG_fail;
22201 }
22202 }
22203 {
22204 PyThreadState* __tstate = wxPyBeginAllowThreads();
22205 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22206
22207 wxPyEndAllowThreads(__tstate);
22208 if (PyErr_Occurred()) SWIG_fail;
22209 }
22210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22211 return resultobj;
22212 fail:
22213 return NULL;
22214 }
22215
22216
22217 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22218 PyObject *resultobj;
22219 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22220 PyObject * obj0 = 0 ;
22221 char *kwnames[] = {
22222 (char *) "self", NULL
22223 };
22224
22225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22227 if (SWIG_arg_fail(1)) SWIG_fail;
22228 {
22229 PyThreadState* __tstate = wxPyBeginAllowThreads();
22230 delete arg1;
22231
22232 wxPyEndAllowThreads(__tstate);
22233 if (PyErr_Occurred()) SWIG_fail;
22234 }
22235 Py_INCREF(Py_None); resultobj = Py_None;
22236 return resultobj;
22237 fail:
22238 return NULL;
22239 }
22240
22241
22242 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22243 PyObject *resultobj;
22244 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22245 PyObject *arg2 = (PyObject *) 0 ;
22246 PyObject * obj0 = 0 ;
22247 PyObject * obj1 = 0 ;
22248 char *kwnames[] = {
22249 (char *) "self",(char *) "self", NULL
22250 };
22251
22252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22254 if (SWIG_arg_fail(1)) SWIG_fail;
22255 arg2 = obj1;
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 (arg1)->SetSelf(arg2);
22259
22260 wxPyEndAllowThreads(__tstate);
22261 if (PyErr_Occurred()) SWIG_fail;
22262 }
22263 Py_INCREF(Py_None); resultobj = Py_None;
22264 return resultobj;
22265 fail:
22266 return NULL;
22267 }
22268
22269
22270 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22271 PyObject *resultobj;
22272 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22273 PyObject *result;
22274 PyObject * obj0 = 0 ;
22275 char *kwnames[] = {
22276 (char *) "self", NULL
22277 };
22278
22279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22281 if (SWIG_arg_fail(1)) SWIG_fail;
22282 {
22283 PyThreadState* __tstate = wxPyBeginAllowThreads();
22284 result = (PyObject *)(arg1)->GetSelf();
22285
22286 wxPyEndAllowThreads(__tstate);
22287 if (PyErr_Occurred()) SWIG_fail;
22288 }
22289 resultobj = result;
22290 return resultobj;
22291 fail:
22292 return NULL;
22293 }
22294
22295
22296 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22297 PyObject *obj;
22298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22299 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22300 Py_INCREF(obj);
22301 return Py_BuildValue((char *)"");
22302 }
22303 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22304 PyObject *resultobj;
22305 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22306 int arg2 = (int) 0 ;
22307 wxPyCommandEvent *result;
22308 PyObject * obj0 = 0 ;
22309 PyObject * obj1 = 0 ;
22310 char *kwnames[] = {
22311 (char *) "commandType",(char *) "id", NULL
22312 };
22313
22314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22315 if (obj0) {
22316 {
22317 arg1 = (wxEventType)(SWIG_As_int(obj0));
22318 if (SWIG_arg_fail(1)) SWIG_fail;
22319 }
22320 }
22321 if (obj1) {
22322 {
22323 arg2 = (int)(SWIG_As_int(obj1));
22324 if (SWIG_arg_fail(2)) SWIG_fail;
22325 }
22326 }
22327 {
22328 PyThreadState* __tstate = wxPyBeginAllowThreads();
22329 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22330
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22342 PyObject *resultobj;
22343 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22344 PyObject * obj0 = 0 ;
22345 char *kwnames[] = {
22346 (char *) "self", NULL
22347 };
22348
22349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22351 if (SWIG_arg_fail(1)) SWIG_fail;
22352 {
22353 PyThreadState* __tstate = wxPyBeginAllowThreads();
22354 delete arg1;
22355
22356 wxPyEndAllowThreads(__tstate);
22357 if (PyErr_Occurred()) SWIG_fail;
22358 }
22359 Py_INCREF(Py_None); resultobj = Py_None;
22360 return resultobj;
22361 fail:
22362 return NULL;
22363 }
22364
22365
22366 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22367 PyObject *resultobj;
22368 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22369 PyObject *arg2 = (PyObject *) 0 ;
22370 PyObject * obj0 = 0 ;
22371 PyObject * obj1 = 0 ;
22372 char *kwnames[] = {
22373 (char *) "self",(char *) "self", NULL
22374 };
22375
22376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22378 if (SWIG_arg_fail(1)) SWIG_fail;
22379 arg2 = obj1;
22380 {
22381 PyThreadState* __tstate = wxPyBeginAllowThreads();
22382 (arg1)->SetSelf(arg2);
22383
22384 wxPyEndAllowThreads(__tstate);
22385 if (PyErr_Occurred()) SWIG_fail;
22386 }
22387 Py_INCREF(Py_None); resultobj = Py_None;
22388 return resultobj;
22389 fail:
22390 return NULL;
22391 }
22392
22393
22394 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22395 PyObject *resultobj;
22396 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22397 PyObject *result;
22398 PyObject * obj0 = 0 ;
22399 char *kwnames[] = {
22400 (char *) "self", NULL
22401 };
22402
22403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22405 if (SWIG_arg_fail(1)) SWIG_fail;
22406 {
22407 PyThreadState* __tstate = wxPyBeginAllowThreads();
22408 result = (PyObject *)(arg1)->GetSelf();
22409
22410 wxPyEndAllowThreads(__tstate);
22411 if (PyErr_Occurred()) SWIG_fail;
22412 }
22413 resultobj = result;
22414 return resultobj;
22415 fail:
22416 return NULL;
22417 }
22418
22419
22420 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22421 PyObject *obj;
22422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22423 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22424 Py_INCREF(obj);
22425 return Py_BuildValue((char *)"");
22426 }
22427 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22428 PyObject *resultobj;
22429 wxWindow *arg1 = (wxWindow *) 0 ;
22430 wxDateTime *arg2 = 0 ;
22431 wxEventType arg3 ;
22432 wxDateEvent *result;
22433 PyObject * obj0 = 0 ;
22434 PyObject * obj1 = 0 ;
22435 PyObject * obj2 = 0 ;
22436 char *kwnames[] = {
22437 (char *) "win",(char *) "dt",(char *) "type", NULL
22438 };
22439
22440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22442 if (SWIG_arg_fail(1)) SWIG_fail;
22443 {
22444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22445 if (SWIG_arg_fail(2)) SWIG_fail;
22446 if (arg2 == NULL) {
22447 SWIG_null_ref("wxDateTime");
22448 }
22449 if (SWIG_arg_fail(2)) SWIG_fail;
22450 }
22451 {
22452 arg3 = (wxEventType)(SWIG_As_int(obj2));
22453 if (SWIG_arg_fail(3)) SWIG_fail;
22454 }
22455 {
22456 PyThreadState* __tstate = wxPyBeginAllowThreads();
22457 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22458
22459 wxPyEndAllowThreads(__tstate);
22460 if (PyErr_Occurred()) SWIG_fail;
22461 }
22462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22463 return resultobj;
22464 fail:
22465 return NULL;
22466 }
22467
22468
22469 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22470 PyObject *resultobj;
22471 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22472 wxDateTime *result;
22473 PyObject * obj0 = 0 ;
22474 char *kwnames[] = {
22475 (char *) "self", NULL
22476 };
22477
22478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22480 if (SWIG_arg_fail(1)) SWIG_fail;
22481 {
22482 PyThreadState* __tstate = wxPyBeginAllowThreads();
22483 {
22484 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22485 result = (wxDateTime *) &_result_ref;
22486 }
22487
22488 wxPyEndAllowThreads(__tstate);
22489 if (PyErr_Occurred()) SWIG_fail;
22490 }
22491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22499 PyObject *resultobj;
22500 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22501 wxDateTime *arg2 = 0 ;
22502 PyObject * obj0 = 0 ;
22503 PyObject * obj1 = 0 ;
22504 char *kwnames[] = {
22505 (char *) "self",(char *) "date", NULL
22506 };
22507
22508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22510 if (SWIG_arg_fail(1)) SWIG_fail;
22511 {
22512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22513 if (SWIG_arg_fail(2)) SWIG_fail;
22514 if (arg2 == NULL) {
22515 SWIG_null_ref("wxDateTime");
22516 }
22517 if (SWIG_arg_fail(2)) SWIG_fail;
22518 }
22519 {
22520 PyThreadState* __tstate = wxPyBeginAllowThreads();
22521 (arg1)->SetDate((wxDateTime const &)*arg2);
22522
22523 wxPyEndAllowThreads(__tstate);
22524 if (PyErr_Occurred()) SWIG_fail;
22525 }
22526 Py_INCREF(Py_None); resultobj = Py_None;
22527 return resultobj;
22528 fail:
22529 return NULL;
22530 }
22531
22532
22533 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22534 PyObject *obj;
22535 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22536 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22537 Py_INCREF(obj);
22538 return Py_BuildValue((char *)"");
22539 }
22540 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22541 PyObject *resultobj;
22542 wxPyApp *result;
22543 char *kwnames[] = {
22544 NULL
22545 };
22546
22547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22548 {
22549 PyThreadState* __tstate = wxPyBeginAllowThreads();
22550 result = (wxPyApp *)new_wxPyApp();
22551
22552 wxPyEndAllowThreads(__tstate);
22553 if (PyErr_Occurred()) SWIG_fail;
22554 }
22555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22556 return resultobj;
22557 fail:
22558 return NULL;
22559 }
22560
22561
22562 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22563 PyObject *resultobj;
22564 wxPyApp *arg1 = (wxPyApp *) 0 ;
22565 PyObject * obj0 = 0 ;
22566 char *kwnames[] = {
22567 (char *) "self", NULL
22568 };
22569
22570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22572 if (SWIG_arg_fail(1)) SWIG_fail;
22573 {
22574 PyThreadState* __tstate = wxPyBeginAllowThreads();
22575 delete arg1;
22576
22577 wxPyEndAllowThreads(__tstate);
22578 if (PyErr_Occurred()) SWIG_fail;
22579 }
22580 Py_INCREF(Py_None); resultobj = Py_None;
22581 return resultobj;
22582 fail:
22583 return NULL;
22584 }
22585
22586
22587 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22588 PyObject *resultobj;
22589 wxPyApp *arg1 = (wxPyApp *) 0 ;
22590 PyObject *arg2 = (PyObject *) 0 ;
22591 PyObject *arg3 = (PyObject *) 0 ;
22592 PyObject * obj0 = 0 ;
22593 PyObject * obj1 = 0 ;
22594 PyObject * obj2 = 0 ;
22595 char *kwnames[] = {
22596 (char *) "self",(char *) "self",(char *) "_class", NULL
22597 };
22598
22599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22601 if (SWIG_arg_fail(1)) SWIG_fail;
22602 arg2 = obj1;
22603 arg3 = obj2;
22604 {
22605 PyThreadState* __tstate = wxPyBeginAllowThreads();
22606 (arg1)->_setCallbackInfo(arg2,arg3);
22607
22608 wxPyEndAllowThreads(__tstate);
22609 if (PyErr_Occurred()) SWIG_fail;
22610 }
22611 Py_INCREF(Py_None); resultobj = Py_None;
22612 return resultobj;
22613 fail:
22614 return NULL;
22615 }
22616
22617
22618 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22619 PyObject *resultobj;
22620 wxPyApp *arg1 = (wxPyApp *) 0 ;
22621 wxString result;
22622 PyObject * obj0 = 0 ;
22623 char *kwnames[] = {
22624 (char *) "self", NULL
22625 };
22626
22627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22629 if (SWIG_arg_fail(1)) SWIG_fail;
22630 {
22631 PyThreadState* __tstate = wxPyBeginAllowThreads();
22632 result = ((wxPyApp const *)arg1)->GetAppName();
22633
22634 wxPyEndAllowThreads(__tstate);
22635 if (PyErr_Occurred()) SWIG_fail;
22636 }
22637 {
22638 #if wxUSE_UNICODE
22639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22640 #else
22641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22642 #endif
22643 }
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22651 PyObject *resultobj;
22652 wxPyApp *arg1 = (wxPyApp *) 0 ;
22653 wxString *arg2 = 0 ;
22654 bool temp2 = false ;
22655 PyObject * obj0 = 0 ;
22656 PyObject * obj1 = 0 ;
22657 char *kwnames[] = {
22658 (char *) "self",(char *) "name", NULL
22659 };
22660
22661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22663 if (SWIG_arg_fail(1)) SWIG_fail;
22664 {
22665 arg2 = wxString_in_helper(obj1);
22666 if (arg2 == NULL) SWIG_fail;
22667 temp2 = true;
22668 }
22669 {
22670 PyThreadState* __tstate = wxPyBeginAllowThreads();
22671 (arg1)->SetAppName((wxString const &)*arg2);
22672
22673 wxPyEndAllowThreads(__tstate);
22674 if (PyErr_Occurred()) SWIG_fail;
22675 }
22676 Py_INCREF(Py_None); resultobj = Py_None;
22677 {
22678 if (temp2)
22679 delete arg2;
22680 }
22681 return resultobj;
22682 fail:
22683 {
22684 if (temp2)
22685 delete arg2;
22686 }
22687 return NULL;
22688 }
22689
22690
22691 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22692 PyObject *resultobj;
22693 wxPyApp *arg1 = (wxPyApp *) 0 ;
22694 wxString result;
22695 PyObject * obj0 = 0 ;
22696 char *kwnames[] = {
22697 (char *) "self", NULL
22698 };
22699
22700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22702 if (SWIG_arg_fail(1)) SWIG_fail;
22703 {
22704 PyThreadState* __tstate = wxPyBeginAllowThreads();
22705 result = ((wxPyApp const *)arg1)->GetClassName();
22706
22707 wxPyEndAllowThreads(__tstate);
22708 if (PyErr_Occurred()) SWIG_fail;
22709 }
22710 {
22711 #if wxUSE_UNICODE
22712 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22713 #else
22714 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22715 #endif
22716 }
22717 return resultobj;
22718 fail:
22719 return NULL;
22720 }
22721
22722
22723 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22724 PyObject *resultobj;
22725 wxPyApp *arg1 = (wxPyApp *) 0 ;
22726 wxString *arg2 = 0 ;
22727 bool temp2 = false ;
22728 PyObject * obj0 = 0 ;
22729 PyObject * obj1 = 0 ;
22730 char *kwnames[] = {
22731 (char *) "self",(char *) "name", NULL
22732 };
22733
22734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22736 if (SWIG_arg_fail(1)) SWIG_fail;
22737 {
22738 arg2 = wxString_in_helper(obj1);
22739 if (arg2 == NULL) SWIG_fail;
22740 temp2 = true;
22741 }
22742 {
22743 PyThreadState* __tstate = wxPyBeginAllowThreads();
22744 (arg1)->SetClassName((wxString const &)*arg2);
22745
22746 wxPyEndAllowThreads(__tstate);
22747 if (PyErr_Occurred()) SWIG_fail;
22748 }
22749 Py_INCREF(Py_None); resultobj = Py_None;
22750 {
22751 if (temp2)
22752 delete arg2;
22753 }
22754 return resultobj;
22755 fail:
22756 {
22757 if (temp2)
22758 delete arg2;
22759 }
22760 return NULL;
22761 }
22762
22763
22764 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22765 PyObject *resultobj;
22766 wxPyApp *arg1 = (wxPyApp *) 0 ;
22767 wxString *result;
22768 PyObject * obj0 = 0 ;
22769 char *kwnames[] = {
22770 (char *) "self", NULL
22771 };
22772
22773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22775 if (SWIG_arg_fail(1)) SWIG_fail;
22776 {
22777 PyThreadState* __tstate = wxPyBeginAllowThreads();
22778 {
22779 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22780 result = (wxString *) &_result_ref;
22781 }
22782
22783 wxPyEndAllowThreads(__tstate);
22784 if (PyErr_Occurred()) SWIG_fail;
22785 }
22786 {
22787 #if wxUSE_UNICODE
22788 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22789 #else
22790 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22791 #endif
22792 }
22793 return resultobj;
22794 fail:
22795 return NULL;
22796 }
22797
22798
22799 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22800 PyObject *resultobj;
22801 wxPyApp *arg1 = (wxPyApp *) 0 ;
22802 wxString *arg2 = 0 ;
22803 bool temp2 = false ;
22804 PyObject * obj0 = 0 ;
22805 PyObject * obj1 = 0 ;
22806 char *kwnames[] = {
22807 (char *) "self",(char *) "name", NULL
22808 };
22809
22810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22812 if (SWIG_arg_fail(1)) SWIG_fail;
22813 {
22814 arg2 = wxString_in_helper(obj1);
22815 if (arg2 == NULL) SWIG_fail;
22816 temp2 = true;
22817 }
22818 {
22819 PyThreadState* __tstate = wxPyBeginAllowThreads();
22820 (arg1)->SetVendorName((wxString const &)*arg2);
22821
22822 wxPyEndAllowThreads(__tstate);
22823 if (PyErr_Occurred()) SWIG_fail;
22824 }
22825 Py_INCREF(Py_None); resultobj = Py_None;
22826 {
22827 if (temp2)
22828 delete arg2;
22829 }
22830 return resultobj;
22831 fail:
22832 {
22833 if (temp2)
22834 delete arg2;
22835 }
22836 return NULL;
22837 }
22838
22839
22840 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22841 PyObject *resultobj;
22842 wxPyApp *arg1 = (wxPyApp *) 0 ;
22843 wxAppTraits *result;
22844 PyObject * obj0 = 0 ;
22845 char *kwnames[] = {
22846 (char *) "self", NULL
22847 };
22848
22849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22851 if (SWIG_arg_fail(1)) SWIG_fail;
22852 {
22853 PyThreadState* __tstate = wxPyBeginAllowThreads();
22854 result = (wxAppTraits *)(arg1)->GetTraits();
22855
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22867 PyObject *resultobj;
22868 wxPyApp *arg1 = (wxPyApp *) 0 ;
22869 PyObject * obj0 = 0 ;
22870 char *kwnames[] = {
22871 (char *) "self", NULL
22872 };
22873
22874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22876 if (SWIG_arg_fail(1)) SWIG_fail;
22877 {
22878 PyThreadState* __tstate = wxPyBeginAllowThreads();
22879 (arg1)->ProcessPendingEvents();
22880
22881 wxPyEndAllowThreads(__tstate);
22882 if (PyErr_Occurred()) SWIG_fail;
22883 }
22884 Py_INCREF(Py_None); resultobj = Py_None;
22885 return resultobj;
22886 fail:
22887 return NULL;
22888 }
22889
22890
22891 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22892 PyObject *resultobj;
22893 wxPyApp *arg1 = (wxPyApp *) 0 ;
22894 bool arg2 = (bool) false ;
22895 bool result;
22896 PyObject * obj0 = 0 ;
22897 PyObject * obj1 = 0 ;
22898 char *kwnames[] = {
22899 (char *) "self",(char *) "onlyIfNeeded", NULL
22900 };
22901
22902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22904 if (SWIG_arg_fail(1)) SWIG_fail;
22905 if (obj1) {
22906 {
22907 arg2 = (bool)(SWIG_As_bool(obj1));
22908 if (SWIG_arg_fail(2)) SWIG_fail;
22909 }
22910 }
22911 {
22912 PyThreadState* __tstate = wxPyBeginAllowThreads();
22913 result = (bool)(arg1)->Yield(arg2);
22914
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 {
22919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22920 }
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22928 PyObject *resultobj;
22929 wxPyApp *arg1 = (wxPyApp *) 0 ;
22930 PyObject * obj0 = 0 ;
22931 char *kwnames[] = {
22932 (char *) "self", NULL
22933 };
22934
22935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22937 if (SWIG_arg_fail(1)) SWIG_fail;
22938 {
22939 PyThreadState* __tstate = wxPyBeginAllowThreads();
22940 (arg1)->WakeUpIdle();
22941
22942 wxPyEndAllowThreads(__tstate);
22943 if (PyErr_Occurred()) SWIG_fail;
22944 }
22945 Py_INCREF(Py_None); resultobj = Py_None;
22946 return resultobj;
22947 fail:
22948 return NULL;
22949 }
22950
22951
22952 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22953 PyObject *resultobj;
22954 bool result;
22955 char *kwnames[] = {
22956 NULL
22957 };
22958
22959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22960 {
22961 PyThreadState* __tstate = wxPyBeginAllowThreads();
22962 result = (bool)wxPyApp::IsMainLoopRunning();
22963
22964 wxPyEndAllowThreads(__tstate);
22965 if (PyErr_Occurred()) SWIG_fail;
22966 }
22967 {
22968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22969 }
22970 return resultobj;
22971 fail:
22972 return NULL;
22973 }
22974
22975
22976 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22977 PyObject *resultobj;
22978 wxPyApp *arg1 = (wxPyApp *) 0 ;
22979 int result;
22980 PyObject * obj0 = 0 ;
22981 char *kwnames[] = {
22982 (char *) "self", NULL
22983 };
22984
22985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22987 if (SWIG_arg_fail(1)) SWIG_fail;
22988 {
22989 PyThreadState* __tstate = wxPyBeginAllowThreads();
22990 result = (int)(arg1)->MainLoop();
22991
22992 wxPyEndAllowThreads(__tstate);
22993 if (PyErr_Occurred()) SWIG_fail;
22994 }
22995 {
22996 resultobj = SWIG_From_int((int)(result));
22997 }
22998 return resultobj;
22999 fail:
23000 return NULL;
23001 }
23002
23003
23004 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23005 PyObject *resultobj;
23006 wxPyApp *arg1 = (wxPyApp *) 0 ;
23007 PyObject * obj0 = 0 ;
23008 char *kwnames[] = {
23009 (char *) "self", NULL
23010 };
23011
23012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23014 if (SWIG_arg_fail(1)) SWIG_fail;
23015 {
23016 PyThreadState* __tstate = wxPyBeginAllowThreads();
23017 (arg1)->Exit();
23018
23019 wxPyEndAllowThreads(__tstate);
23020 if (PyErr_Occurred()) SWIG_fail;
23021 }
23022 Py_INCREF(Py_None); resultobj = Py_None;
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23030 PyObject *resultobj;
23031 wxPyApp *arg1 = (wxPyApp *) 0 ;
23032 PyObject * obj0 = 0 ;
23033 char *kwnames[] = {
23034 (char *) "self", NULL
23035 };
23036
23037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23039 if (SWIG_arg_fail(1)) SWIG_fail;
23040 {
23041 PyThreadState* __tstate = wxPyBeginAllowThreads();
23042 (arg1)->ExitMainLoop();
23043
23044 wxPyEndAllowThreads(__tstate);
23045 if (PyErr_Occurred()) SWIG_fail;
23046 }
23047 Py_INCREF(Py_None); resultobj = Py_None;
23048 return resultobj;
23049 fail:
23050 return NULL;
23051 }
23052
23053
23054 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23055 PyObject *resultobj;
23056 wxPyApp *arg1 = (wxPyApp *) 0 ;
23057 bool result;
23058 PyObject * obj0 = 0 ;
23059 char *kwnames[] = {
23060 (char *) "self", NULL
23061 };
23062
23063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23065 if (SWIG_arg_fail(1)) SWIG_fail;
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 result = (bool)(arg1)->Pending();
23069
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 {
23074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23075 }
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23083 PyObject *resultobj;
23084 wxPyApp *arg1 = (wxPyApp *) 0 ;
23085 bool result;
23086 PyObject * obj0 = 0 ;
23087 char *kwnames[] = {
23088 (char *) "self", NULL
23089 };
23090
23091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23093 if (SWIG_arg_fail(1)) SWIG_fail;
23094 {
23095 PyThreadState* __tstate = wxPyBeginAllowThreads();
23096 result = (bool)(arg1)->Dispatch();
23097
23098 wxPyEndAllowThreads(__tstate);
23099 if (PyErr_Occurred()) SWIG_fail;
23100 }
23101 {
23102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23103 }
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23111 PyObject *resultobj;
23112 wxPyApp *arg1 = (wxPyApp *) 0 ;
23113 bool result;
23114 PyObject * obj0 = 0 ;
23115 char *kwnames[] = {
23116 (char *) "self", NULL
23117 };
23118
23119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23121 if (SWIG_arg_fail(1)) SWIG_fail;
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 result = (bool)(arg1)->ProcessIdle();
23125
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 {
23130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23131 }
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23139 PyObject *resultobj;
23140 wxPyApp *arg1 = (wxPyApp *) 0 ;
23141 wxWindow *arg2 = (wxWindow *) 0 ;
23142 wxIdleEvent *arg3 = 0 ;
23143 bool result;
23144 PyObject * obj0 = 0 ;
23145 PyObject * obj1 = 0 ;
23146 PyObject * obj2 = 0 ;
23147 char *kwnames[] = {
23148 (char *) "self",(char *) "win",(char *) "event", NULL
23149 };
23150
23151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23153 if (SWIG_arg_fail(1)) SWIG_fail;
23154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23155 if (SWIG_arg_fail(2)) SWIG_fail;
23156 {
23157 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23158 if (SWIG_arg_fail(3)) SWIG_fail;
23159 if (arg3 == NULL) {
23160 SWIG_null_ref("wxIdleEvent");
23161 }
23162 if (SWIG_arg_fail(3)) SWIG_fail;
23163 }
23164 {
23165 PyThreadState* __tstate = wxPyBeginAllowThreads();
23166 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23167
23168 wxPyEndAllowThreads(__tstate);
23169 if (PyErr_Occurred()) SWIG_fail;
23170 }
23171 {
23172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23173 }
23174 return resultobj;
23175 fail:
23176 return NULL;
23177 }
23178
23179
23180 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23181 PyObject *resultobj;
23182 wxPyApp *arg1 = (wxPyApp *) 0 ;
23183 bool result;
23184 PyObject * obj0 = 0 ;
23185 char *kwnames[] = {
23186 (char *) "self", NULL
23187 };
23188
23189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23191 if (SWIG_arg_fail(1)) SWIG_fail;
23192 {
23193 PyThreadState* __tstate = wxPyBeginAllowThreads();
23194 result = (bool)((wxPyApp const *)arg1)->IsActive();
23195
23196 wxPyEndAllowThreads(__tstate);
23197 if (PyErr_Occurred()) SWIG_fail;
23198 }
23199 {
23200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23201 }
23202 return resultobj;
23203 fail:
23204 return NULL;
23205 }
23206
23207
23208 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23209 PyObject *resultobj;
23210 wxPyApp *arg1 = (wxPyApp *) 0 ;
23211 wxWindow *arg2 = (wxWindow *) 0 ;
23212 PyObject * obj0 = 0 ;
23213 PyObject * obj1 = 0 ;
23214 char *kwnames[] = {
23215 (char *) "self",(char *) "win", NULL
23216 };
23217
23218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23220 if (SWIG_arg_fail(1)) SWIG_fail;
23221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23222 if (SWIG_arg_fail(2)) SWIG_fail;
23223 {
23224 PyThreadState* __tstate = wxPyBeginAllowThreads();
23225 (arg1)->SetTopWindow(arg2);
23226
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 Py_INCREF(Py_None); resultobj = Py_None;
23231 return resultobj;
23232 fail:
23233 return NULL;
23234 }
23235
23236
23237 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23238 PyObject *resultobj;
23239 wxPyApp *arg1 = (wxPyApp *) 0 ;
23240 wxWindow *result;
23241 PyObject * obj0 = 0 ;
23242 char *kwnames[] = {
23243 (char *) "self", NULL
23244 };
23245
23246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23248 if (SWIG_arg_fail(1)) SWIG_fail;
23249 {
23250 PyThreadState* __tstate = wxPyBeginAllowThreads();
23251 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23252
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 {
23257 resultobj = wxPyMake_wxObject(result, 0);
23258 }
23259 return resultobj;
23260 fail:
23261 return NULL;
23262 }
23263
23264
23265 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23266 PyObject *resultobj;
23267 wxPyApp *arg1 = (wxPyApp *) 0 ;
23268 bool arg2 ;
23269 PyObject * obj0 = 0 ;
23270 PyObject * obj1 = 0 ;
23271 char *kwnames[] = {
23272 (char *) "self",(char *) "flag", NULL
23273 };
23274
23275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23277 if (SWIG_arg_fail(1)) SWIG_fail;
23278 {
23279 arg2 = (bool)(SWIG_As_bool(obj1));
23280 if (SWIG_arg_fail(2)) SWIG_fail;
23281 }
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 (arg1)->SetExitOnFrameDelete(arg2);
23285
23286 wxPyEndAllowThreads(__tstate);
23287 if (PyErr_Occurred()) SWIG_fail;
23288 }
23289 Py_INCREF(Py_None); resultobj = Py_None;
23290 return resultobj;
23291 fail:
23292 return NULL;
23293 }
23294
23295
23296 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23297 PyObject *resultobj;
23298 wxPyApp *arg1 = (wxPyApp *) 0 ;
23299 bool result;
23300 PyObject * obj0 = 0 ;
23301 char *kwnames[] = {
23302 (char *) "self", NULL
23303 };
23304
23305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23307 if (SWIG_arg_fail(1)) SWIG_fail;
23308 {
23309 PyThreadState* __tstate = wxPyBeginAllowThreads();
23310 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23311
23312 wxPyEndAllowThreads(__tstate);
23313 if (PyErr_Occurred()) SWIG_fail;
23314 }
23315 {
23316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23317 }
23318 return resultobj;
23319 fail:
23320 return NULL;
23321 }
23322
23323
23324 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23325 PyObject *resultobj;
23326 wxPyApp *arg1 = (wxPyApp *) 0 ;
23327 bool arg2 ;
23328 PyObject * obj0 = 0 ;
23329 PyObject * obj1 = 0 ;
23330 char *kwnames[] = {
23331 (char *) "self",(char *) "flag", NULL
23332 };
23333
23334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23336 if (SWIG_arg_fail(1)) SWIG_fail;
23337 {
23338 arg2 = (bool)(SWIG_As_bool(obj1));
23339 if (SWIG_arg_fail(2)) SWIG_fail;
23340 }
23341 {
23342 PyThreadState* __tstate = wxPyBeginAllowThreads();
23343 (arg1)->SetUseBestVisual(arg2);
23344
23345 wxPyEndAllowThreads(__tstate);
23346 if (PyErr_Occurred()) SWIG_fail;
23347 }
23348 Py_INCREF(Py_None); resultobj = Py_None;
23349 return resultobj;
23350 fail:
23351 return NULL;
23352 }
23353
23354
23355 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23356 PyObject *resultobj;
23357 wxPyApp *arg1 = (wxPyApp *) 0 ;
23358 bool result;
23359 PyObject * obj0 = 0 ;
23360 char *kwnames[] = {
23361 (char *) "self", NULL
23362 };
23363
23364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23366 if (SWIG_arg_fail(1)) SWIG_fail;
23367 {
23368 PyThreadState* __tstate = wxPyBeginAllowThreads();
23369 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23370
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 {
23375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23376 }
23377 return resultobj;
23378 fail:
23379 return NULL;
23380 }
23381
23382
23383 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj;
23385 wxPyApp *arg1 = (wxPyApp *) 0 ;
23386 int arg2 ;
23387 PyObject * obj0 = 0 ;
23388 PyObject * obj1 = 0 ;
23389 char *kwnames[] = {
23390 (char *) "self",(char *) "mode", NULL
23391 };
23392
23393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23395 if (SWIG_arg_fail(1)) SWIG_fail;
23396 {
23397 arg2 = (int)(SWIG_As_int(obj1));
23398 if (SWIG_arg_fail(2)) SWIG_fail;
23399 }
23400 {
23401 PyThreadState* __tstate = wxPyBeginAllowThreads();
23402 (arg1)->SetPrintMode(arg2);
23403
23404 wxPyEndAllowThreads(__tstate);
23405 if (PyErr_Occurred()) SWIG_fail;
23406 }
23407 Py_INCREF(Py_None); resultobj = Py_None;
23408 return resultobj;
23409 fail:
23410 return NULL;
23411 }
23412
23413
23414 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23415 PyObject *resultobj;
23416 wxPyApp *arg1 = (wxPyApp *) 0 ;
23417 int result;
23418 PyObject * obj0 = 0 ;
23419 char *kwnames[] = {
23420 (char *) "self", NULL
23421 };
23422
23423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23425 if (SWIG_arg_fail(1)) SWIG_fail;
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23429
23430 wxPyEndAllowThreads(__tstate);
23431 if (PyErr_Occurred()) SWIG_fail;
23432 }
23433 {
23434 resultobj = SWIG_From_int((int)(result));
23435 }
23436 return resultobj;
23437 fail:
23438 return NULL;
23439 }
23440
23441
23442 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj;
23444 wxPyApp *arg1 = (wxPyApp *) 0 ;
23445 int arg2 ;
23446 PyObject * obj0 = 0 ;
23447 PyObject * obj1 = 0 ;
23448 char *kwnames[] = {
23449 (char *) "self",(char *) "mode", NULL
23450 };
23451
23452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23454 if (SWIG_arg_fail(1)) SWIG_fail;
23455 {
23456 arg2 = (int)(SWIG_As_int(obj1));
23457 if (SWIG_arg_fail(2)) SWIG_fail;
23458 }
23459 {
23460 PyThreadState* __tstate = wxPyBeginAllowThreads();
23461 (arg1)->SetAssertMode(arg2);
23462
23463 wxPyEndAllowThreads(__tstate);
23464 if (PyErr_Occurred()) SWIG_fail;
23465 }
23466 Py_INCREF(Py_None); resultobj = Py_None;
23467 return resultobj;
23468 fail:
23469 return NULL;
23470 }
23471
23472
23473 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23474 PyObject *resultobj;
23475 wxPyApp *arg1 = (wxPyApp *) 0 ;
23476 int result;
23477 PyObject * obj0 = 0 ;
23478 char *kwnames[] = {
23479 (char *) "self", NULL
23480 };
23481
23482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23484 if (SWIG_arg_fail(1)) SWIG_fail;
23485 {
23486 PyThreadState* __tstate = wxPyBeginAllowThreads();
23487 result = (int)(arg1)->GetAssertMode();
23488
23489 wxPyEndAllowThreads(__tstate);
23490 if (PyErr_Occurred()) SWIG_fail;
23491 }
23492 {
23493 resultobj = SWIG_From_int((int)(result));
23494 }
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23502 PyObject *resultobj;
23503 bool result;
23504 char *kwnames[] = {
23505 NULL
23506 };
23507
23508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23509 {
23510 PyThreadState* __tstate = wxPyBeginAllowThreads();
23511 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23512
23513 wxPyEndAllowThreads(__tstate);
23514 if (PyErr_Occurred()) SWIG_fail;
23515 }
23516 {
23517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23518 }
23519 return resultobj;
23520 fail:
23521 return NULL;
23522 }
23523
23524
23525 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23526 PyObject *resultobj;
23527 long result;
23528 char *kwnames[] = {
23529 NULL
23530 };
23531
23532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23533 {
23534 PyThreadState* __tstate = wxPyBeginAllowThreads();
23535 result = (long)wxPyApp::GetMacAboutMenuItemId();
23536
23537 wxPyEndAllowThreads(__tstate);
23538 if (PyErr_Occurred()) SWIG_fail;
23539 }
23540 {
23541 resultobj = SWIG_From_long((long)(result));
23542 }
23543 return resultobj;
23544 fail:
23545 return NULL;
23546 }
23547
23548
23549 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23550 PyObject *resultobj;
23551 long result;
23552 char *kwnames[] = {
23553 NULL
23554 };
23555
23556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23557 {
23558 PyThreadState* __tstate = wxPyBeginAllowThreads();
23559 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23560
23561 wxPyEndAllowThreads(__tstate);
23562 if (PyErr_Occurred()) SWIG_fail;
23563 }
23564 {
23565 resultobj = SWIG_From_long((long)(result));
23566 }
23567 return resultobj;
23568 fail:
23569 return NULL;
23570 }
23571
23572
23573 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23574 PyObject *resultobj;
23575 long result;
23576 char *kwnames[] = {
23577 NULL
23578 };
23579
23580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23581 {
23582 PyThreadState* __tstate = wxPyBeginAllowThreads();
23583 result = (long)wxPyApp::GetMacExitMenuItemId();
23584
23585 wxPyEndAllowThreads(__tstate);
23586 if (PyErr_Occurred()) SWIG_fail;
23587 }
23588 {
23589 resultobj = SWIG_From_long((long)(result));
23590 }
23591 return resultobj;
23592 fail:
23593 return NULL;
23594 }
23595
23596
23597 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23598 PyObject *resultobj;
23599 wxString result;
23600 char *kwnames[] = {
23601 NULL
23602 };
23603
23604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23605 {
23606 PyThreadState* __tstate = wxPyBeginAllowThreads();
23607 result = wxPyApp::GetMacHelpMenuTitleName();
23608
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 {
23613 #if wxUSE_UNICODE
23614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23615 #else
23616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23617 #endif
23618 }
23619 return resultobj;
23620 fail:
23621 return NULL;
23622 }
23623
23624
23625 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23626 PyObject *resultobj;
23627 bool arg1 ;
23628 PyObject * obj0 = 0 ;
23629 char *kwnames[] = {
23630 (char *) "val", NULL
23631 };
23632
23633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23634 {
23635 arg1 = (bool)(SWIG_As_bool(obj0));
23636 if (SWIG_arg_fail(1)) SWIG_fail;
23637 }
23638 {
23639 PyThreadState* __tstate = wxPyBeginAllowThreads();
23640 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23641
23642 wxPyEndAllowThreads(__tstate);
23643 if (PyErr_Occurred()) SWIG_fail;
23644 }
23645 Py_INCREF(Py_None); resultobj = Py_None;
23646 return resultobj;
23647 fail:
23648 return NULL;
23649 }
23650
23651
23652 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23653 PyObject *resultobj;
23654 long arg1 ;
23655 PyObject * obj0 = 0 ;
23656 char *kwnames[] = {
23657 (char *) "val", NULL
23658 };
23659
23660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23661 {
23662 arg1 = (long)(SWIG_As_long(obj0));
23663 if (SWIG_arg_fail(1)) SWIG_fail;
23664 }
23665 {
23666 PyThreadState* __tstate = wxPyBeginAllowThreads();
23667 wxPyApp::SetMacAboutMenuItemId(arg1);
23668
23669 wxPyEndAllowThreads(__tstate);
23670 if (PyErr_Occurred()) SWIG_fail;
23671 }
23672 Py_INCREF(Py_None); resultobj = Py_None;
23673 return resultobj;
23674 fail:
23675 return NULL;
23676 }
23677
23678
23679 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23680 PyObject *resultobj;
23681 long arg1 ;
23682 PyObject * obj0 = 0 ;
23683 char *kwnames[] = {
23684 (char *) "val", NULL
23685 };
23686
23687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23688 {
23689 arg1 = (long)(SWIG_As_long(obj0));
23690 if (SWIG_arg_fail(1)) SWIG_fail;
23691 }
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23695
23696 wxPyEndAllowThreads(__tstate);
23697 if (PyErr_Occurred()) SWIG_fail;
23698 }
23699 Py_INCREF(Py_None); resultobj = Py_None;
23700 return resultobj;
23701 fail:
23702 return NULL;
23703 }
23704
23705
23706 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23707 PyObject *resultobj;
23708 long arg1 ;
23709 PyObject * obj0 = 0 ;
23710 char *kwnames[] = {
23711 (char *) "val", NULL
23712 };
23713
23714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23715 {
23716 arg1 = (long)(SWIG_As_long(obj0));
23717 if (SWIG_arg_fail(1)) SWIG_fail;
23718 }
23719 {
23720 PyThreadState* __tstate = wxPyBeginAllowThreads();
23721 wxPyApp::SetMacExitMenuItemId(arg1);
23722
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 Py_INCREF(Py_None); resultobj = Py_None;
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23734 PyObject *resultobj;
23735 wxString *arg1 = 0 ;
23736 bool temp1 = false ;
23737 PyObject * obj0 = 0 ;
23738 char *kwnames[] = {
23739 (char *) "val", NULL
23740 };
23741
23742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23743 {
23744 arg1 = wxString_in_helper(obj0);
23745 if (arg1 == NULL) SWIG_fail;
23746 temp1 = true;
23747 }
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23751
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 Py_INCREF(Py_None); resultobj = Py_None;
23756 {
23757 if (temp1)
23758 delete arg1;
23759 }
23760 return resultobj;
23761 fail:
23762 {
23763 if (temp1)
23764 delete arg1;
23765 }
23766 return NULL;
23767 }
23768
23769
23770 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23771 PyObject *resultobj;
23772 wxPyApp *arg1 = (wxPyApp *) 0 ;
23773 PyObject * obj0 = 0 ;
23774 char *kwnames[] = {
23775 (char *) "self", NULL
23776 };
23777
23778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23780 if (SWIG_arg_fail(1)) SWIG_fail;
23781 {
23782 PyThreadState* __tstate = wxPyBeginAllowThreads();
23783 (arg1)->_BootstrapApp();
23784
23785 wxPyEndAllowThreads(__tstate);
23786 if (PyErr_Occurred()) SWIG_fail;
23787 }
23788 Py_INCREF(Py_None); resultobj = Py_None;
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23796 PyObject *resultobj;
23797 int result;
23798 char *kwnames[] = {
23799 NULL
23800 };
23801
23802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23803 {
23804 PyThreadState* __tstate = wxPyBeginAllowThreads();
23805 result = (int)wxPyApp::GetComCtl32Version();
23806
23807 wxPyEndAllowThreads(__tstate);
23808 if (PyErr_Occurred()) SWIG_fail;
23809 }
23810 {
23811 resultobj = SWIG_From_int((int)(result));
23812 }
23813 return resultobj;
23814 fail:
23815 return NULL;
23816 }
23817
23818
23819 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23820 PyObject *obj;
23821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23822 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23823 Py_INCREF(obj);
23824 return Py_BuildValue((char *)"");
23825 }
23826 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23827 PyObject *resultobj;
23828 char *kwnames[] = {
23829 NULL
23830 };
23831
23832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23833 {
23834 PyThreadState* __tstate = wxPyBeginAllowThreads();
23835 wxExit();
23836
23837 wxPyEndAllowThreads(__tstate);
23838 if (PyErr_Occurred()) SWIG_fail;
23839 }
23840 Py_INCREF(Py_None); resultobj = Py_None;
23841 return resultobj;
23842 fail:
23843 return NULL;
23844 }
23845
23846
23847 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23848 PyObject *resultobj;
23849 bool result;
23850 char *kwnames[] = {
23851 NULL
23852 };
23853
23854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = (bool)wxYield();
23858
23859 wxPyEndAllowThreads(__tstate);
23860 if (PyErr_Occurred()) SWIG_fail;
23861 }
23862 {
23863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23864 }
23865 return resultobj;
23866 fail:
23867 return NULL;
23868 }
23869
23870
23871 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23872 PyObject *resultobj;
23873 bool result;
23874 char *kwnames[] = {
23875 NULL
23876 };
23877
23878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23879 {
23880 PyThreadState* __tstate = wxPyBeginAllowThreads();
23881 result = (bool)wxYieldIfNeeded();
23882
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 {
23887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23888 }
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23896 PyObject *resultobj;
23897 wxWindow *arg1 = (wxWindow *) NULL ;
23898 bool arg2 = (bool) false ;
23899 bool result;
23900 PyObject * obj0 = 0 ;
23901 PyObject * obj1 = 0 ;
23902 char *kwnames[] = {
23903 (char *) "win",(char *) "onlyIfNeeded", NULL
23904 };
23905
23906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23907 if (obj0) {
23908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23909 if (SWIG_arg_fail(1)) SWIG_fail;
23910 }
23911 if (obj1) {
23912 {
23913 arg2 = (bool)(SWIG_As_bool(obj1));
23914 if (SWIG_arg_fail(2)) SWIG_fail;
23915 }
23916 }
23917 {
23918 PyThreadState* __tstate = wxPyBeginAllowThreads();
23919 result = (bool)wxSafeYield(arg1,arg2);
23920
23921 wxPyEndAllowThreads(__tstate);
23922 if (PyErr_Occurred()) SWIG_fail;
23923 }
23924 {
23925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23926 }
23927 return resultobj;
23928 fail:
23929 return NULL;
23930 }
23931
23932
23933 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23934 PyObject *resultobj;
23935 char *kwnames[] = {
23936 NULL
23937 };
23938
23939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23940 {
23941 PyThreadState* __tstate = wxPyBeginAllowThreads();
23942 wxWakeUpIdle();
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 *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23955 PyObject *resultobj;
23956 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23957 wxEvent *arg2 = 0 ;
23958 PyObject * obj0 = 0 ;
23959 PyObject * obj1 = 0 ;
23960 char *kwnames[] = {
23961 (char *) "dest",(char *) "event", NULL
23962 };
23963
23964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23966 if (SWIG_arg_fail(1)) SWIG_fail;
23967 {
23968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23969 if (SWIG_arg_fail(2)) SWIG_fail;
23970 if (arg2 == NULL) {
23971 SWIG_null_ref("wxEvent");
23972 }
23973 if (SWIG_arg_fail(2)) SWIG_fail;
23974 }
23975 {
23976 PyThreadState* __tstate = wxPyBeginAllowThreads();
23977 wxPostEvent(arg1,*arg2);
23978
23979 wxPyEndAllowThreads(__tstate);
23980 if (PyErr_Occurred()) SWIG_fail;
23981 }
23982 Py_INCREF(Py_None); resultobj = Py_None;
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23990 PyObject *resultobj;
23991 char *kwnames[] = {
23992 NULL
23993 };
23994
23995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23996 {
23997 PyThreadState* __tstate = wxPyBeginAllowThreads();
23998 wxApp_CleanUp();
23999
24000 wxPyEndAllowThreads(__tstate);
24001 if (PyErr_Occurred()) SWIG_fail;
24002 }
24003 Py_INCREF(Py_None); resultobj = Py_None;
24004 return resultobj;
24005 fail:
24006 return NULL;
24007 }
24008
24009
24010 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24011 PyObject *resultobj;
24012 wxPyApp *result;
24013 char *kwnames[] = {
24014 NULL
24015 };
24016
24017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24018 {
24019 PyThreadState* __tstate = wxPyBeginAllowThreads();
24020 result = (wxPyApp *)wxPyGetApp();
24021
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 {
24026 resultobj = wxPyMake_wxObject(result, 0);
24027 }
24028 return resultobj;
24029 fail:
24030 return NULL;
24031 }
24032
24033
24034 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24035 PyObject *resultobj;
24036 char *arg1 = (char *) 0 ;
24037 PyObject * obj0 = 0 ;
24038 char *kwnames[] = {
24039 (char *) "encoding", NULL
24040 };
24041
24042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24043 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24044 SWIG_arg_fail(1);SWIG_fail;
24045 }
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 wxSetDefaultPyEncoding((char const *)arg1);
24049
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 Py_INCREF(Py_None); resultobj = Py_None;
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj;
24062 char *result;
24063 char *kwnames[] = {
24064 NULL
24065 };
24066
24067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24068 {
24069 PyThreadState* __tstate = wxPyBeginAllowThreads();
24070 result = (char *)wxGetDefaultPyEncoding();
24071
24072 wxPyEndAllowThreads(__tstate);
24073 if (PyErr_Occurred()) SWIG_fail;
24074 }
24075 resultobj = SWIG_FromCharPtr(result);
24076 return resultobj;
24077 fail:
24078 return NULL;
24079 }
24080
24081
24082 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24083 PyObject *resultobj;
24084 wxEventLoop *result;
24085 char *kwnames[] = {
24086 NULL
24087 };
24088
24089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24090 {
24091 PyThreadState* __tstate = wxPyBeginAllowThreads();
24092 result = (wxEventLoop *)new wxEventLoop();
24093
24094 wxPyEndAllowThreads(__tstate);
24095 if (PyErr_Occurred()) SWIG_fail;
24096 }
24097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24098 return resultobj;
24099 fail:
24100 return NULL;
24101 }
24102
24103
24104 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24105 PyObject *resultobj;
24106 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24107 PyObject * obj0 = 0 ;
24108 char *kwnames[] = {
24109 (char *) "self", NULL
24110 };
24111
24112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24114 if (SWIG_arg_fail(1)) SWIG_fail;
24115 {
24116 PyThreadState* __tstate = wxPyBeginAllowThreads();
24117 delete arg1;
24118
24119 wxPyEndAllowThreads(__tstate);
24120 if (PyErr_Occurred()) SWIG_fail;
24121 }
24122 Py_INCREF(Py_None); resultobj = Py_None;
24123 return resultobj;
24124 fail:
24125 return NULL;
24126 }
24127
24128
24129 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24130 PyObject *resultobj;
24131 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24132 int result;
24133 PyObject * obj0 = 0 ;
24134 char *kwnames[] = {
24135 (char *) "self", NULL
24136 };
24137
24138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24140 if (SWIG_arg_fail(1)) SWIG_fail;
24141 {
24142 PyThreadState* __tstate = wxPyBeginAllowThreads();
24143 result = (int)(arg1)->Run();
24144
24145 wxPyEndAllowThreads(__tstate);
24146 if (PyErr_Occurred()) SWIG_fail;
24147 }
24148 {
24149 resultobj = SWIG_From_int((int)(result));
24150 }
24151 return resultobj;
24152 fail:
24153 return NULL;
24154 }
24155
24156
24157 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24158 PyObject *resultobj;
24159 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24160 int arg2 = (int) 0 ;
24161 PyObject * obj0 = 0 ;
24162 PyObject * obj1 = 0 ;
24163 char *kwnames[] = {
24164 (char *) "self",(char *) "rc", NULL
24165 };
24166
24167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24169 if (SWIG_arg_fail(1)) SWIG_fail;
24170 if (obj1) {
24171 {
24172 arg2 = (int)(SWIG_As_int(obj1));
24173 if (SWIG_arg_fail(2)) SWIG_fail;
24174 }
24175 }
24176 {
24177 PyThreadState* __tstate = wxPyBeginAllowThreads();
24178 (arg1)->Exit(arg2);
24179
24180 wxPyEndAllowThreads(__tstate);
24181 if (PyErr_Occurred()) SWIG_fail;
24182 }
24183 Py_INCREF(Py_None); resultobj = Py_None;
24184 return resultobj;
24185 fail:
24186 return NULL;
24187 }
24188
24189
24190 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24191 PyObject *resultobj;
24192 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24193 bool result;
24194 PyObject * obj0 = 0 ;
24195 char *kwnames[] = {
24196 (char *) "self", NULL
24197 };
24198
24199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24201 if (SWIG_arg_fail(1)) SWIG_fail;
24202 {
24203 PyThreadState* __tstate = wxPyBeginAllowThreads();
24204 result = (bool)((wxEventLoop const *)arg1)->Pending();
24205
24206 wxPyEndAllowThreads(__tstate);
24207 if (PyErr_Occurred()) SWIG_fail;
24208 }
24209 {
24210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24211 }
24212 return resultobj;
24213 fail:
24214 return NULL;
24215 }
24216
24217
24218 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24219 PyObject *resultobj;
24220 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24221 bool result;
24222 PyObject * obj0 = 0 ;
24223 char *kwnames[] = {
24224 (char *) "self", NULL
24225 };
24226
24227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24229 if (SWIG_arg_fail(1)) SWIG_fail;
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = (bool)(arg1)->Dispatch();
24233
24234 wxPyEndAllowThreads(__tstate);
24235 if (PyErr_Occurred()) SWIG_fail;
24236 }
24237 {
24238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24239 }
24240 return resultobj;
24241 fail:
24242 return NULL;
24243 }
24244
24245
24246 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24247 PyObject *resultobj;
24248 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24249 bool result;
24250 PyObject * obj0 = 0 ;
24251 char *kwnames[] = {
24252 (char *) "self", NULL
24253 };
24254
24255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24257 if (SWIG_arg_fail(1)) SWIG_fail;
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24261
24262 wxPyEndAllowThreads(__tstate);
24263 if (PyErr_Occurred()) SWIG_fail;
24264 }
24265 {
24266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24267 }
24268 return resultobj;
24269 fail:
24270 return NULL;
24271 }
24272
24273
24274 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24275 PyObject *resultobj;
24276 wxEventLoop *result;
24277 char *kwnames[] = {
24278 NULL
24279 };
24280
24281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24282 {
24283 PyThreadState* __tstate = wxPyBeginAllowThreads();
24284 result = (wxEventLoop *)wxEventLoop::GetActive();
24285
24286 wxPyEndAllowThreads(__tstate);
24287 if (PyErr_Occurred()) SWIG_fail;
24288 }
24289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj;
24298 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24299 PyObject * obj0 = 0 ;
24300 char *kwnames[] = {
24301 (char *) "loop", NULL
24302 };
24303
24304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24306 if (SWIG_arg_fail(1)) SWIG_fail;
24307 {
24308 PyThreadState* __tstate = wxPyBeginAllowThreads();
24309 wxEventLoop::SetActive(arg1);
24310
24311 wxPyEndAllowThreads(__tstate);
24312 if (PyErr_Occurred()) SWIG_fail;
24313 }
24314 Py_INCREF(Py_None); resultobj = Py_None;
24315 return resultobj;
24316 fail:
24317 return NULL;
24318 }
24319
24320
24321 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24322 PyObject *obj;
24323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24324 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24325 Py_INCREF(obj);
24326 return Py_BuildValue((char *)"");
24327 }
24328 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24329 PyObject *resultobj;
24330 int arg1 = (int) 0 ;
24331 int arg2 = (int) 0 ;
24332 int arg3 = (int) 0 ;
24333 wxAcceleratorEntry *result;
24334 PyObject * obj0 = 0 ;
24335 PyObject * obj1 = 0 ;
24336 PyObject * obj2 = 0 ;
24337 char *kwnames[] = {
24338 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24339 };
24340
24341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24342 if (obj0) {
24343 {
24344 arg1 = (int)(SWIG_As_int(obj0));
24345 if (SWIG_arg_fail(1)) SWIG_fail;
24346 }
24347 }
24348 if (obj1) {
24349 {
24350 arg2 = (int)(SWIG_As_int(obj1));
24351 if (SWIG_arg_fail(2)) SWIG_fail;
24352 }
24353 }
24354 if (obj2) {
24355 {
24356 arg3 = (int)(SWIG_As_int(obj2));
24357 if (SWIG_arg_fail(3)) SWIG_fail;
24358 }
24359 }
24360 {
24361 PyThreadState* __tstate = wxPyBeginAllowThreads();
24362 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24363
24364 wxPyEndAllowThreads(__tstate);
24365 if (PyErr_Occurred()) SWIG_fail;
24366 }
24367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24368 return resultobj;
24369 fail:
24370 return NULL;
24371 }
24372
24373
24374 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24375 PyObject *resultobj;
24376 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24377 PyObject * obj0 = 0 ;
24378 char *kwnames[] = {
24379 (char *) "self", NULL
24380 };
24381
24382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24384 if (SWIG_arg_fail(1)) SWIG_fail;
24385 {
24386 PyThreadState* __tstate = wxPyBeginAllowThreads();
24387 delete arg1;
24388
24389 wxPyEndAllowThreads(__tstate);
24390 if (PyErr_Occurred()) SWIG_fail;
24391 }
24392 Py_INCREF(Py_None); resultobj = Py_None;
24393 return resultobj;
24394 fail:
24395 return NULL;
24396 }
24397
24398
24399 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24400 PyObject *resultobj;
24401 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24402 int arg2 ;
24403 int arg3 ;
24404 int arg4 ;
24405 PyObject * obj0 = 0 ;
24406 PyObject * obj1 = 0 ;
24407 PyObject * obj2 = 0 ;
24408 PyObject * obj3 = 0 ;
24409 char *kwnames[] = {
24410 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24411 };
24412
24413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24415 if (SWIG_arg_fail(1)) SWIG_fail;
24416 {
24417 arg2 = (int)(SWIG_As_int(obj1));
24418 if (SWIG_arg_fail(2)) SWIG_fail;
24419 }
24420 {
24421 arg3 = (int)(SWIG_As_int(obj2));
24422 if (SWIG_arg_fail(3)) SWIG_fail;
24423 }
24424 {
24425 arg4 = (int)(SWIG_As_int(obj3));
24426 if (SWIG_arg_fail(4)) SWIG_fail;
24427 }
24428 {
24429 PyThreadState* __tstate = wxPyBeginAllowThreads();
24430 (arg1)->Set(arg2,arg3,arg4);
24431
24432 wxPyEndAllowThreads(__tstate);
24433 if (PyErr_Occurred()) SWIG_fail;
24434 }
24435 Py_INCREF(Py_None); resultobj = Py_None;
24436 return resultobj;
24437 fail:
24438 return NULL;
24439 }
24440
24441
24442 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24443 PyObject *resultobj;
24444 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24445 int result;
24446 PyObject * obj0 = 0 ;
24447 char *kwnames[] = {
24448 (char *) "self", NULL
24449 };
24450
24451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24453 if (SWIG_arg_fail(1)) SWIG_fail;
24454 {
24455 PyThreadState* __tstate = wxPyBeginAllowThreads();
24456 result = (int)(arg1)->GetFlags();
24457
24458 wxPyEndAllowThreads(__tstate);
24459 if (PyErr_Occurred()) SWIG_fail;
24460 }
24461 {
24462 resultobj = SWIG_From_int((int)(result));
24463 }
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24471 PyObject *resultobj;
24472 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24473 int result;
24474 PyObject * obj0 = 0 ;
24475 char *kwnames[] = {
24476 (char *) "self", NULL
24477 };
24478
24479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24481 if (SWIG_arg_fail(1)) SWIG_fail;
24482 {
24483 PyThreadState* __tstate = wxPyBeginAllowThreads();
24484 result = (int)(arg1)->GetKeyCode();
24485
24486 wxPyEndAllowThreads(__tstate);
24487 if (PyErr_Occurred()) SWIG_fail;
24488 }
24489 {
24490 resultobj = SWIG_From_int((int)(result));
24491 }
24492 return resultobj;
24493 fail:
24494 return NULL;
24495 }
24496
24497
24498 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24499 PyObject *resultobj;
24500 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24501 int result;
24502 PyObject * obj0 = 0 ;
24503 char *kwnames[] = {
24504 (char *) "self", NULL
24505 };
24506
24507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24509 if (SWIG_arg_fail(1)) SWIG_fail;
24510 {
24511 PyThreadState* __tstate = wxPyBeginAllowThreads();
24512 result = (int)(arg1)->GetCommand();
24513
24514 wxPyEndAllowThreads(__tstate);
24515 if (PyErr_Occurred()) SWIG_fail;
24516 }
24517 {
24518 resultobj = SWIG_From_int((int)(result));
24519 }
24520 return resultobj;
24521 fail:
24522 return NULL;
24523 }
24524
24525
24526 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24527 PyObject *obj;
24528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24529 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24530 Py_INCREF(obj);
24531 return Py_BuildValue((char *)"");
24532 }
24533 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24534 PyObject *resultobj;
24535 int arg1 ;
24536 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24537 wxAcceleratorTable *result;
24538 PyObject * obj0 = 0 ;
24539 char *kwnames[] = {
24540 (char *) "n", NULL
24541 };
24542
24543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24544 {
24545 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24546 if (arg2) arg1 = PyList_Size(obj0);
24547 else arg1 = 0;
24548 }
24549 {
24550 PyThreadState* __tstate = wxPyBeginAllowThreads();
24551 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24552
24553 wxPyEndAllowThreads(__tstate);
24554 if (PyErr_Occurred()) SWIG_fail;
24555 }
24556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24557 {
24558 delete [] arg2;
24559 }
24560 return resultobj;
24561 fail:
24562 {
24563 delete [] arg2;
24564 }
24565 return NULL;
24566 }
24567
24568
24569 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24570 PyObject *resultobj;
24571 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24572 PyObject * obj0 = 0 ;
24573 char *kwnames[] = {
24574 (char *) "self", NULL
24575 };
24576
24577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24579 if (SWIG_arg_fail(1)) SWIG_fail;
24580 {
24581 PyThreadState* __tstate = wxPyBeginAllowThreads();
24582 delete arg1;
24583
24584 wxPyEndAllowThreads(__tstate);
24585 if (PyErr_Occurred()) SWIG_fail;
24586 }
24587 Py_INCREF(Py_None); resultobj = Py_None;
24588 return resultobj;
24589 fail:
24590 return NULL;
24591 }
24592
24593
24594 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24595 PyObject *resultobj;
24596 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24597 bool result;
24598 PyObject * obj0 = 0 ;
24599 char *kwnames[] = {
24600 (char *) "self", NULL
24601 };
24602
24603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24605 if (SWIG_arg_fail(1)) SWIG_fail;
24606 {
24607 PyThreadState* __tstate = wxPyBeginAllowThreads();
24608 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24609
24610 wxPyEndAllowThreads(__tstate);
24611 if (PyErr_Occurred()) SWIG_fail;
24612 }
24613 {
24614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24615 }
24616 return resultobj;
24617 fail:
24618 return NULL;
24619 }
24620
24621
24622 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24623 PyObject *obj;
24624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24625 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24626 Py_INCREF(obj);
24627 return Py_BuildValue((char *)"");
24628 }
24629 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24630 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24631 return 1;
24632 }
24633
24634
24635 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24636 PyObject *pyobj;
24637
24638 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24639 return pyobj;
24640 }
24641
24642
24643 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24644 PyObject *resultobj;
24645 wxString *arg1 = 0 ;
24646 wxAcceleratorEntry *result;
24647 bool temp1 = false ;
24648 PyObject * obj0 = 0 ;
24649 char *kwnames[] = {
24650 (char *) "label", NULL
24651 };
24652
24653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24654 {
24655 arg1 = wxString_in_helper(obj0);
24656 if (arg1 == NULL) SWIG_fail;
24657 temp1 = true;
24658 }
24659 {
24660 PyThreadState* __tstate = wxPyBeginAllowThreads();
24661 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24662
24663 wxPyEndAllowThreads(__tstate);
24664 if (PyErr_Occurred()) SWIG_fail;
24665 }
24666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24667 {
24668 if (temp1)
24669 delete arg1;
24670 }
24671 return resultobj;
24672 fail:
24673 {
24674 if (temp1)
24675 delete arg1;
24676 }
24677 return NULL;
24678 }
24679
24680
24681 static int _wrap_PanelNameStr_set(PyObject *) {
24682 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24683 return 1;
24684 }
24685
24686
24687 static PyObject *_wrap_PanelNameStr_get(void) {
24688 PyObject *pyobj;
24689
24690 {
24691 #if wxUSE_UNICODE
24692 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24693 #else
24694 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24695 #endif
24696 }
24697 return pyobj;
24698 }
24699
24700
24701 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24702 PyObject *resultobj;
24703 wxVisualAttributes *result;
24704 char *kwnames[] = {
24705 NULL
24706 };
24707
24708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 result = (wxVisualAttributes *)new_wxVisualAttributes();
24712
24713 wxPyEndAllowThreads(__tstate);
24714 if (PyErr_Occurred()) SWIG_fail;
24715 }
24716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24717 return resultobj;
24718 fail:
24719 return NULL;
24720 }
24721
24722
24723 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24724 PyObject *resultobj;
24725 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24726 PyObject * obj0 = 0 ;
24727 char *kwnames[] = {
24728 (char *) "self", NULL
24729 };
24730
24731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24733 if (SWIG_arg_fail(1)) SWIG_fail;
24734 {
24735 PyThreadState* __tstate = wxPyBeginAllowThreads();
24736 delete_wxVisualAttributes(arg1);
24737
24738 wxPyEndAllowThreads(__tstate);
24739 if (PyErr_Occurred()) SWIG_fail;
24740 }
24741 Py_INCREF(Py_None); resultobj = Py_None;
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24749 PyObject *resultobj;
24750 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24751 wxFont *arg2 = (wxFont *) 0 ;
24752 PyObject * obj0 = 0 ;
24753 PyObject * obj1 = 0 ;
24754 char *kwnames[] = {
24755 (char *) "self",(char *) "font", NULL
24756 };
24757
24758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24760 if (SWIG_arg_fail(1)) SWIG_fail;
24761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24762 if (SWIG_arg_fail(2)) SWIG_fail;
24763 if (arg1) (arg1)->font = *arg2;
24764
24765 Py_INCREF(Py_None); resultobj = Py_None;
24766 return resultobj;
24767 fail:
24768 return NULL;
24769 }
24770
24771
24772 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24773 PyObject *resultobj;
24774 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24775 wxFont *result;
24776 PyObject * obj0 = 0 ;
24777 char *kwnames[] = {
24778 (char *) "self", NULL
24779 };
24780
24781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24783 if (SWIG_arg_fail(1)) SWIG_fail;
24784 result = (wxFont *)& ((arg1)->font);
24785
24786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24787 return resultobj;
24788 fail:
24789 return NULL;
24790 }
24791
24792
24793 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24794 PyObject *resultobj;
24795 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24796 wxColour *arg2 = (wxColour *) 0 ;
24797 PyObject * obj0 = 0 ;
24798 PyObject * obj1 = 0 ;
24799 char *kwnames[] = {
24800 (char *) "self",(char *) "colFg", NULL
24801 };
24802
24803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24805 if (SWIG_arg_fail(1)) SWIG_fail;
24806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24807 if (SWIG_arg_fail(2)) SWIG_fail;
24808 if (arg1) (arg1)->colFg = *arg2;
24809
24810 Py_INCREF(Py_None); resultobj = Py_None;
24811 return resultobj;
24812 fail:
24813 return NULL;
24814 }
24815
24816
24817 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24818 PyObject *resultobj;
24819 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24820 wxColour *result;
24821 PyObject * obj0 = 0 ;
24822 char *kwnames[] = {
24823 (char *) "self", NULL
24824 };
24825
24826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24828 if (SWIG_arg_fail(1)) SWIG_fail;
24829 result = (wxColour *)& ((arg1)->colFg);
24830
24831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24832 return resultobj;
24833 fail:
24834 return NULL;
24835 }
24836
24837
24838 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24839 PyObject *resultobj;
24840 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24841 wxColour *arg2 = (wxColour *) 0 ;
24842 PyObject * obj0 = 0 ;
24843 PyObject * obj1 = 0 ;
24844 char *kwnames[] = {
24845 (char *) "self",(char *) "colBg", NULL
24846 };
24847
24848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24850 if (SWIG_arg_fail(1)) SWIG_fail;
24851 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24852 if (SWIG_arg_fail(2)) SWIG_fail;
24853 if (arg1) (arg1)->colBg = *arg2;
24854
24855 Py_INCREF(Py_None); resultobj = Py_None;
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24863 PyObject *resultobj;
24864 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24865 wxColour *result;
24866 PyObject * obj0 = 0 ;
24867 char *kwnames[] = {
24868 (char *) "self", NULL
24869 };
24870
24871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24873 if (SWIG_arg_fail(1)) SWIG_fail;
24874 result = (wxColour *)& ((arg1)->colBg);
24875
24876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24877 return resultobj;
24878 fail:
24879 return NULL;
24880 }
24881
24882
24883 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24884 PyObject *obj;
24885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24886 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24887 Py_INCREF(obj);
24888 return Py_BuildValue((char *)"");
24889 }
24890 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24891 PyObject *resultobj;
24892 wxWindow *arg1 = (wxWindow *) 0 ;
24893 int arg2 = (int) (int)-1 ;
24894 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24895 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24896 wxSize const &arg4_defvalue = wxDefaultSize ;
24897 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24898 long arg5 = (long) 0 ;
24899 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24900 wxString *arg6 = (wxString *) &arg6_defvalue ;
24901 wxWindow *result;
24902 wxPoint temp3 ;
24903 wxSize temp4 ;
24904 bool temp6 = false ;
24905 PyObject * obj0 = 0 ;
24906 PyObject * obj1 = 0 ;
24907 PyObject * obj2 = 0 ;
24908 PyObject * obj3 = 0 ;
24909 PyObject * obj4 = 0 ;
24910 PyObject * obj5 = 0 ;
24911 char *kwnames[] = {
24912 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24913 };
24914
24915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24917 if (SWIG_arg_fail(1)) SWIG_fail;
24918 if (obj1) {
24919 {
24920 arg2 = (int const)(SWIG_As_int(obj1));
24921 if (SWIG_arg_fail(2)) SWIG_fail;
24922 }
24923 }
24924 if (obj2) {
24925 {
24926 arg3 = &temp3;
24927 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24928 }
24929 }
24930 if (obj3) {
24931 {
24932 arg4 = &temp4;
24933 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24934 }
24935 }
24936 if (obj4) {
24937 {
24938 arg5 = (long)(SWIG_As_long(obj4));
24939 if (SWIG_arg_fail(5)) SWIG_fail;
24940 }
24941 }
24942 if (obj5) {
24943 {
24944 arg6 = wxString_in_helper(obj5);
24945 if (arg6 == NULL) SWIG_fail;
24946 temp6 = true;
24947 }
24948 }
24949 {
24950 if (!wxPyCheckForApp()) SWIG_fail;
24951 PyThreadState* __tstate = wxPyBeginAllowThreads();
24952 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24953
24954 wxPyEndAllowThreads(__tstate);
24955 if (PyErr_Occurred()) SWIG_fail;
24956 }
24957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24958 {
24959 if (temp6)
24960 delete arg6;
24961 }
24962 return resultobj;
24963 fail:
24964 {
24965 if (temp6)
24966 delete arg6;
24967 }
24968 return NULL;
24969 }
24970
24971
24972 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24973 PyObject *resultobj;
24974 wxWindow *result;
24975 char *kwnames[] = {
24976 NULL
24977 };
24978
24979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24980 {
24981 if (!wxPyCheckForApp()) SWIG_fail;
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = (wxWindow *)new wxWindow();
24984
24985 wxPyEndAllowThreads(__tstate);
24986 if (PyErr_Occurred()) SWIG_fail;
24987 }
24988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24989 return resultobj;
24990 fail:
24991 return NULL;
24992 }
24993
24994
24995 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24996 PyObject *resultobj;
24997 wxWindow *arg1 = (wxWindow *) 0 ;
24998 wxWindow *arg2 = (wxWindow *) 0 ;
24999 int arg3 = (int) (int)-1 ;
25000 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25001 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25002 wxSize const &arg5_defvalue = wxDefaultSize ;
25003 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25004 long arg6 = (long) 0 ;
25005 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25006 wxString *arg7 = (wxString *) &arg7_defvalue ;
25007 bool result;
25008 wxPoint temp4 ;
25009 wxSize temp5 ;
25010 bool temp7 = false ;
25011 PyObject * obj0 = 0 ;
25012 PyObject * obj1 = 0 ;
25013 PyObject * obj2 = 0 ;
25014 PyObject * obj3 = 0 ;
25015 PyObject * obj4 = 0 ;
25016 PyObject * obj5 = 0 ;
25017 PyObject * obj6 = 0 ;
25018 char *kwnames[] = {
25019 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25020 };
25021
25022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25024 if (SWIG_arg_fail(1)) SWIG_fail;
25025 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25026 if (SWIG_arg_fail(2)) SWIG_fail;
25027 if (obj2) {
25028 {
25029 arg3 = (int const)(SWIG_As_int(obj2));
25030 if (SWIG_arg_fail(3)) SWIG_fail;
25031 }
25032 }
25033 if (obj3) {
25034 {
25035 arg4 = &temp4;
25036 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25037 }
25038 }
25039 if (obj4) {
25040 {
25041 arg5 = &temp5;
25042 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25043 }
25044 }
25045 if (obj5) {
25046 {
25047 arg6 = (long)(SWIG_As_long(obj5));
25048 if (SWIG_arg_fail(6)) SWIG_fail;
25049 }
25050 }
25051 if (obj6) {
25052 {
25053 arg7 = wxString_in_helper(obj6);
25054 if (arg7 == NULL) SWIG_fail;
25055 temp7 = true;
25056 }
25057 }
25058 {
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25061
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 {
25066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25067 }
25068 {
25069 if (temp7)
25070 delete arg7;
25071 }
25072 return resultobj;
25073 fail:
25074 {
25075 if (temp7)
25076 delete arg7;
25077 }
25078 return NULL;
25079 }
25080
25081
25082 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25083 PyObject *resultobj;
25084 wxWindow *arg1 = (wxWindow *) 0 ;
25085 bool arg2 = (bool) false ;
25086 bool result;
25087 PyObject * obj0 = 0 ;
25088 PyObject * obj1 = 0 ;
25089 char *kwnames[] = {
25090 (char *) "self",(char *) "force", NULL
25091 };
25092
25093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25095 if (SWIG_arg_fail(1)) SWIG_fail;
25096 if (obj1) {
25097 {
25098 arg2 = (bool)(SWIG_As_bool(obj1));
25099 if (SWIG_arg_fail(2)) SWIG_fail;
25100 }
25101 }
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 result = (bool)(arg1)->Close(arg2);
25105
25106 wxPyEndAllowThreads(__tstate);
25107 if (PyErr_Occurred()) SWIG_fail;
25108 }
25109 {
25110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25111 }
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25119 PyObject *resultobj;
25120 wxWindow *arg1 = (wxWindow *) 0 ;
25121 bool result;
25122 PyObject * obj0 = 0 ;
25123 char *kwnames[] = {
25124 (char *) "self", NULL
25125 };
25126
25127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25129 if (SWIG_arg_fail(1)) SWIG_fail;
25130 {
25131 PyThreadState* __tstate = wxPyBeginAllowThreads();
25132 result = (bool)(arg1)->Destroy();
25133
25134 wxPyEndAllowThreads(__tstate);
25135 if (PyErr_Occurred()) SWIG_fail;
25136 }
25137 {
25138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25139 }
25140 return resultobj;
25141 fail:
25142 return NULL;
25143 }
25144
25145
25146 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25147 PyObject *resultobj;
25148 wxWindow *arg1 = (wxWindow *) 0 ;
25149 bool result;
25150 PyObject * obj0 = 0 ;
25151 char *kwnames[] = {
25152 (char *) "self", NULL
25153 };
25154
25155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25157 if (SWIG_arg_fail(1)) SWIG_fail;
25158 {
25159 PyThreadState* __tstate = wxPyBeginAllowThreads();
25160 result = (bool)(arg1)->DestroyChildren();
25161
25162 wxPyEndAllowThreads(__tstate);
25163 if (PyErr_Occurred()) SWIG_fail;
25164 }
25165 {
25166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25167 }
25168 return resultobj;
25169 fail:
25170 return NULL;
25171 }
25172
25173
25174 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25175 PyObject *resultobj;
25176 wxWindow *arg1 = (wxWindow *) 0 ;
25177 bool result;
25178 PyObject * obj0 = 0 ;
25179 char *kwnames[] = {
25180 (char *) "self", NULL
25181 };
25182
25183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25185 if (SWIG_arg_fail(1)) SWIG_fail;
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25189
25190 wxPyEndAllowThreads(__tstate);
25191 if (PyErr_Occurred()) SWIG_fail;
25192 }
25193 {
25194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25195 }
25196 return resultobj;
25197 fail:
25198 return NULL;
25199 }
25200
25201
25202 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25203 PyObject *resultobj;
25204 wxWindow *arg1 = (wxWindow *) 0 ;
25205 wxString *arg2 = 0 ;
25206 bool temp2 = false ;
25207 PyObject * obj0 = 0 ;
25208 PyObject * obj1 = 0 ;
25209 char *kwnames[] = {
25210 (char *) "self",(char *) "title", NULL
25211 };
25212
25213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25215 if (SWIG_arg_fail(1)) SWIG_fail;
25216 {
25217 arg2 = wxString_in_helper(obj1);
25218 if (arg2 == NULL) SWIG_fail;
25219 temp2 = true;
25220 }
25221 {
25222 PyThreadState* __tstate = wxPyBeginAllowThreads();
25223 (arg1)->SetTitle((wxString const &)*arg2);
25224
25225 wxPyEndAllowThreads(__tstate);
25226 if (PyErr_Occurred()) SWIG_fail;
25227 }
25228 Py_INCREF(Py_None); resultobj = Py_None;
25229 {
25230 if (temp2)
25231 delete arg2;
25232 }
25233 return resultobj;
25234 fail:
25235 {
25236 if (temp2)
25237 delete arg2;
25238 }
25239 return NULL;
25240 }
25241
25242
25243 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25244 PyObject *resultobj;
25245 wxWindow *arg1 = (wxWindow *) 0 ;
25246 wxString result;
25247 PyObject * obj0 = 0 ;
25248 char *kwnames[] = {
25249 (char *) "self", NULL
25250 };
25251
25252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25254 if (SWIG_arg_fail(1)) SWIG_fail;
25255 {
25256 PyThreadState* __tstate = wxPyBeginAllowThreads();
25257 result = ((wxWindow const *)arg1)->GetTitle();
25258
25259 wxPyEndAllowThreads(__tstate);
25260 if (PyErr_Occurred()) SWIG_fail;
25261 }
25262 {
25263 #if wxUSE_UNICODE
25264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25265 #else
25266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25267 #endif
25268 }
25269 return resultobj;
25270 fail:
25271 return NULL;
25272 }
25273
25274
25275 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25276 PyObject *resultobj;
25277 wxWindow *arg1 = (wxWindow *) 0 ;
25278 wxString *arg2 = 0 ;
25279 bool temp2 = false ;
25280 PyObject * obj0 = 0 ;
25281 PyObject * obj1 = 0 ;
25282 char *kwnames[] = {
25283 (char *) "self",(char *) "label", NULL
25284 };
25285
25286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25288 if (SWIG_arg_fail(1)) SWIG_fail;
25289 {
25290 arg2 = wxString_in_helper(obj1);
25291 if (arg2 == NULL) SWIG_fail;
25292 temp2 = true;
25293 }
25294 {
25295 PyThreadState* __tstate = wxPyBeginAllowThreads();
25296 (arg1)->SetLabel((wxString const &)*arg2);
25297
25298 wxPyEndAllowThreads(__tstate);
25299 if (PyErr_Occurred()) SWIG_fail;
25300 }
25301 Py_INCREF(Py_None); resultobj = Py_None;
25302 {
25303 if (temp2)
25304 delete arg2;
25305 }
25306 return resultobj;
25307 fail:
25308 {
25309 if (temp2)
25310 delete arg2;
25311 }
25312 return NULL;
25313 }
25314
25315
25316 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25317 PyObject *resultobj;
25318 wxWindow *arg1 = (wxWindow *) 0 ;
25319 wxString result;
25320 PyObject * obj0 = 0 ;
25321 char *kwnames[] = {
25322 (char *) "self", NULL
25323 };
25324
25325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25327 if (SWIG_arg_fail(1)) SWIG_fail;
25328 {
25329 PyThreadState* __tstate = wxPyBeginAllowThreads();
25330 result = ((wxWindow const *)arg1)->GetLabel();
25331
25332 wxPyEndAllowThreads(__tstate);
25333 if (PyErr_Occurred()) SWIG_fail;
25334 }
25335 {
25336 #if wxUSE_UNICODE
25337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25338 #else
25339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25340 #endif
25341 }
25342 return resultobj;
25343 fail:
25344 return NULL;
25345 }
25346
25347
25348 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25349 PyObject *resultobj;
25350 wxWindow *arg1 = (wxWindow *) 0 ;
25351 wxString *arg2 = 0 ;
25352 bool temp2 = false ;
25353 PyObject * obj0 = 0 ;
25354 PyObject * obj1 = 0 ;
25355 char *kwnames[] = {
25356 (char *) "self",(char *) "name", NULL
25357 };
25358
25359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25361 if (SWIG_arg_fail(1)) SWIG_fail;
25362 {
25363 arg2 = wxString_in_helper(obj1);
25364 if (arg2 == NULL) SWIG_fail;
25365 temp2 = true;
25366 }
25367 {
25368 PyThreadState* __tstate = wxPyBeginAllowThreads();
25369 (arg1)->SetName((wxString const &)*arg2);
25370
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 Py_INCREF(Py_None); resultobj = Py_None;
25375 {
25376 if (temp2)
25377 delete arg2;
25378 }
25379 return resultobj;
25380 fail:
25381 {
25382 if (temp2)
25383 delete arg2;
25384 }
25385 return NULL;
25386 }
25387
25388
25389 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25390 PyObject *resultobj;
25391 wxWindow *arg1 = (wxWindow *) 0 ;
25392 wxString result;
25393 PyObject * obj0 = 0 ;
25394 char *kwnames[] = {
25395 (char *) "self", NULL
25396 };
25397
25398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25400 if (SWIG_arg_fail(1)) SWIG_fail;
25401 {
25402 PyThreadState* __tstate = wxPyBeginAllowThreads();
25403 result = ((wxWindow const *)arg1)->GetName();
25404
25405 wxPyEndAllowThreads(__tstate);
25406 if (PyErr_Occurred()) SWIG_fail;
25407 }
25408 {
25409 #if wxUSE_UNICODE
25410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25411 #else
25412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25413 #endif
25414 }
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25422 PyObject *resultobj;
25423 wxWindow *arg1 = (wxWindow *) 0 ;
25424 wxWindowVariant arg2 ;
25425 PyObject * obj0 = 0 ;
25426 PyObject * obj1 = 0 ;
25427 char *kwnames[] = {
25428 (char *) "self",(char *) "variant", NULL
25429 };
25430
25431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25433 if (SWIG_arg_fail(1)) SWIG_fail;
25434 {
25435 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25436 if (SWIG_arg_fail(2)) SWIG_fail;
25437 }
25438 {
25439 PyThreadState* __tstate = wxPyBeginAllowThreads();
25440 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25441
25442 wxPyEndAllowThreads(__tstate);
25443 if (PyErr_Occurred()) SWIG_fail;
25444 }
25445 Py_INCREF(Py_None); resultobj = Py_None;
25446 return resultobj;
25447 fail:
25448 return NULL;
25449 }
25450
25451
25452 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25453 PyObject *resultobj;
25454 wxWindow *arg1 = (wxWindow *) 0 ;
25455 wxWindowVariant result;
25456 PyObject * obj0 = 0 ;
25457 char *kwnames[] = {
25458 (char *) "self", NULL
25459 };
25460
25461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25463 if (SWIG_arg_fail(1)) SWIG_fail;
25464 {
25465 PyThreadState* __tstate = wxPyBeginAllowThreads();
25466 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25467
25468 wxPyEndAllowThreads(__tstate);
25469 if (PyErr_Occurred()) SWIG_fail;
25470 }
25471 resultobj = SWIG_From_int((result));
25472 return resultobj;
25473 fail:
25474 return NULL;
25475 }
25476
25477
25478 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25479 PyObject *resultobj;
25480 wxWindow *arg1 = (wxWindow *) 0 ;
25481 int arg2 ;
25482 PyObject * obj0 = 0 ;
25483 PyObject * obj1 = 0 ;
25484 char *kwnames[] = {
25485 (char *) "self",(char *) "winid", NULL
25486 };
25487
25488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25490 if (SWIG_arg_fail(1)) SWIG_fail;
25491 {
25492 arg2 = (int)(SWIG_As_int(obj1));
25493 if (SWIG_arg_fail(2)) SWIG_fail;
25494 }
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 (arg1)->SetId(arg2);
25498
25499 wxPyEndAllowThreads(__tstate);
25500 if (PyErr_Occurred()) SWIG_fail;
25501 }
25502 Py_INCREF(Py_None); resultobj = Py_None;
25503 return resultobj;
25504 fail:
25505 return NULL;
25506 }
25507
25508
25509 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25510 PyObject *resultobj;
25511 wxWindow *arg1 = (wxWindow *) 0 ;
25512 int result;
25513 PyObject * obj0 = 0 ;
25514 char *kwnames[] = {
25515 (char *) "self", NULL
25516 };
25517
25518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25520 if (SWIG_arg_fail(1)) SWIG_fail;
25521 {
25522 PyThreadState* __tstate = wxPyBeginAllowThreads();
25523 result = (int)((wxWindow const *)arg1)->GetId();
25524
25525 wxPyEndAllowThreads(__tstate);
25526 if (PyErr_Occurred()) SWIG_fail;
25527 }
25528 {
25529 resultobj = SWIG_From_int((int)(result));
25530 }
25531 return resultobj;
25532 fail:
25533 return NULL;
25534 }
25535
25536
25537 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25538 PyObject *resultobj;
25539 int result;
25540 char *kwnames[] = {
25541 NULL
25542 };
25543
25544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25545 {
25546 PyThreadState* __tstate = wxPyBeginAllowThreads();
25547 result = (int)wxWindow::NewControlId();
25548
25549 wxPyEndAllowThreads(__tstate);
25550 if (PyErr_Occurred()) SWIG_fail;
25551 }
25552 {
25553 resultobj = SWIG_From_int((int)(result));
25554 }
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25562 PyObject *resultobj;
25563 int arg1 ;
25564 int result;
25565 PyObject * obj0 = 0 ;
25566 char *kwnames[] = {
25567 (char *) "winid", NULL
25568 };
25569
25570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25571 {
25572 arg1 = (int)(SWIG_As_int(obj0));
25573 if (SWIG_arg_fail(1)) SWIG_fail;
25574 }
25575 {
25576 PyThreadState* __tstate = wxPyBeginAllowThreads();
25577 result = (int)wxWindow::NextControlId(arg1);
25578
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 {
25583 resultobj = SWIG_From_int((int)(result));
25584 }
25585 return resultobj;
25586 fail:
25587 return NULL;
25588 }
25589
25590
25591 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25592 PyObject *resultobj;
25593 int arg1 ;
25594 int result;
25595 PyObject * obj0 = 0 ;
25596 char *kwnames[] = {
25597 (char *) "winid", NULL
25598 };
25599
25600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25601 {
25602 arg1 = (int)(SWIG_As_int(obj0));
25603 if (SWIG_arg_fail(1)) SWIG_fail;
25604 }
25605 {
25606 PyThreadState* __tstate = wxPyBeginAllowThreads();
25607 result = (int)wxWindow::PrevControlId(arg1);
25608
25609 wxPyEndAllowThreads(__tstate);
25610 if (PyErr_Occurred()) SWIG_fail;
25611 }
25612 {
25613 resultobj = SWIG_From_int((int)(result));
25614 }
25615 return resultobj;
25616 fail:
25617 return NULL;
25618 }
25619
25620
25621 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25622 PyObject *resultobj;
25623 wxWindow *arg1 = (wxWindow *) 0 ;
25624 wxSize *arg2 = 0 ;
25625 wxSize temp2 ;
25626 PyObject * obj0 = 0 ;
25627 PyObject * obj1 = 0 ;
25628 char *kwnames[] = {
25629 (char *) "self",(char *) "size", NULL
25630 };
25631
25632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25634 if (SWIG_arg_fail(1)) SWIG_fail;
25635 {
25636 arg2 = &temp2;
25637 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25638 }
25639 {
25640 PyThreadState* __tstate = wxPyBeginAllowThreads();
25641 (arg1)->SetSize((wxSize const &)*arg2);
25642
25643 wxPyEndAllowThreads(__tstate);
25644 if (PyErr_Occurred()) SWIG_fail;
25645 }
25646 Py_INCREF(Py_None); resultobj = Py_None;
25647 return resultobj;
25648 fail:
25649 return NULL;
25650 }
25651
25652
25653 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25654 PyObject *resultobj;
25655 wxWindow *arg1 = (wxWindow *) 0 ;
25656 int arg2 ;
25657 int arg3 ;
25658 int arg4 ;
25659 int arg5 ;
25660 int arg6 = (int) wxSIZE_AUTO ;
25661 PyObject * obj0 = 0 ;
25662 PyObject * obj1 = 0 ;
25663 PyObject * obj2 = 0 ;
25664 PyObject * obj3 = 0 ;
25665 PyObject * obj4 = 0 ;
25666 PyObject * obj5 = 0 ;
25667 char *kwnames[] = {
25668 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25669 };
25670
25671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25673 if (SWIG_arg_fail(1)) SWIG_fail;
25674 {
25675 arg2 = (int)(SWIG_As_int(obj1));
25676 if (SWIG_arg_fail(2)) SWIG_fail;
25677 }
25678 {
25679 arg3 = (int)(SWIG_As_int(obj2));
25680 if (SWIG_arg_fail(3)) SWIG_fail;
25681 }
25682 {
25683 arg4 = (int)(SWIG_As_int(obj3));
25684 if (SWIG_arg_fail(4)) SWIG_fail;
25685 }
25686 {
25687 arg5 = (int)(SWIG_As_int(obj4));
25688 if (SWIG_arg_fail(5)) SWIG_fail;
25689 }
25690 if (obj5) {
25691 {
25692 arg6 = (int)(SWIG_As_int(obj5));
25693 if (SWIG_arg_fail(6)) SWIG_fail;
25694 }
25695 }
25696 {
25697 PyThreadState* __tstate = wxPyBeginAllowThreads();
25698 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25699
25700 wxPyEndAllowThreads(__tstate);
25701 if (PyErr_Occurred()) SWIG_fail;
25702 }
25703 Py_INCREF(Py_None); resultobj = Py_None;
25704 return resultobj;
25705 fail:
25706 return NULL;
25707 }
25708
25709
25710 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25711 PyObject *resultobj;
25712 wxWindow *arg1 = (wxWindow *) 0 ;
25713 wxRect *arg2 = 0 ;
25714 int arg3 = (int) wxSIZE_AUTO ;
25715 wxRect temp2 ;
25716 PyObject * obj0 = 0 ;
25717 PyObject * obj1 = 0 ;
25718 PyObject * obj2 = 0 ;
25719 char *kwnames[] = {
25720 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25721 };
25722
25723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25725 if (SWIG_arg_fail(1)) SWIG_fail;
25726 {
25727 arg2 = &temp2;
25728 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25729 }
25730 if (obj2) {
25731 {
25732 arg3 = (int)(SWIG_As_int(obj2));
25733 if (SWIG_arg_fail(3)) SWIG_fail;
25734 }
25735 }
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25739
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 Py_INCREF(Py_None); resultobj = Py_None;
25744 return resultobj;
25745 fail:
25746 return NULL;
25747 }
25748
25749
25750 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25751 PyObject *resultobj;
25752 wxWindow *arg1 = (wxWindow *) 0 ;
25753 int arg2 ;
25754 int arg3 ;
25755 PyObject * obj0 = 0 ;
25756 PyObject * obj1 = 0 ;
25757 PyObject * obj2 = 0 ;
25758 char *kwnames[] = {
25759 (char *) "self",(char *) "width",(char *) "height", NULL
25760 };
25761
25762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25764 if (SWIG_arg_fail(1)) SWIG_fail;
25765 {
25766 arg2 = (int)(SWIG_As_int(obj1));
25767 if (SWIG_arg_fail(2)) SWIG_fail;
25768 }
25769 {
25770 arg3 = (int)(SWIG_As_int(obj2));
25771 if (SWIG_arg_fail(3)) SWIG_fail;
25772 }
25773 {
25774 PyThreadState* __tstate = wxPyBeginAllowThreads();
25775 (arg1)->SetSize(arg2,arg3);
25776
25777 wxPyEndAllowThreads(__tstate);
25778 if (PyErr_Occurred()) SWIG_fail;
25779 }
25780 Py_INCREF(Py_None); resultobj = Py_None;
25781 return resultobj;
25782 fail:
25783 return NULL;
25784 }
25785
25786
25787 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25788 PyObject *resultobj;
25789 wxWindow *arg1 = (wxWindow *) 0 ;
25790 wxPoint *arg2 = 0 ;
25791 int arg3 = (int) wxSIZE_USE_EXISTING ;
25792 wxPoint temp2 ;
25793 PyObject * obj0 = 0 ;
25794 PyObject * obj1 = 0 ;
25795 PyObject * obj2 = 0 ;
25796 char *kwnames[] = {
25797 (char *) "self",(char *) "pt",(char *) "flags", NULL
25798 };
25799
25800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25802 if (SWIG_arg_fail(1)) SWIG_fail;
25803 {
25804 arg2 = &temp2;
25805 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25806 }
25807 if (obj2) {
25808 {
25809 arg3 = (int)(SWIG_As_int(obj2));
25810 if (SWIG_arg_fail(3)) SWIG_fail;
25811 }
25812 }
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 (arg1)->Move((wxPoint const &)*arg2,arg3);
25816
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 Py_INCREF(Py_None); resultobj = Py_None;
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj;
25829 wxWindow *arg1 = (wxWindow *) 0 ;
25830 int arg2 ;
25831 int arg3 ;
25832 int arg4 = (int) wxSIZE_USE_EXISTING ;
25833 PyObject * obj0 = 0 ;
25834 PyObject * obj1 = 0 ;
25835 PyObject * obj2 = 0 ;
25836 PyObject * obj3 = 0 ;
25837 char *kwnames[] = {
25838 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25839 };
25840
25841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25843 if (SWIG_arg_fail(1)) SWIG_fail;
25844 {
25845 arg2 = (int)(SWIG_As_int(obj1));
25846 if (SWIG_arg_fail(2)) SWIG_fail;
25847 }
25848 {
25849 arg3 = (int)(SWIG_As_int(obj2));
25850 if (SWIG_arg_fail(3)) SWIG_fail;
25851 }
25852 if (obj3) {
25853 {
25854 arg4 = (int)(SWIG_As_int(obj3));
25855 if (SWIG_arg_fail(4)) SWIG_fail;
25856 }
25857 }
25858 {
25859 PyThreadState* __tstate = wxPyBeginAllowThreads();
25860 (arg1)->Move(arg2,arg3,arg4);
25861
25862 wxPyEndAllowThreads(__tstate);
25863 if (PyErr_Occurred()) SWIG_fail;
25864 }
25865 Py_INCREF(Py_None); resultobj = Py_None;
25866 return resultobj;
25867 fail:
25868 return NULL;
25869 }
25870
25871
25872 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25873 PyObject *resultobj;
25874 wxWindow *arg1 = (wxWindow *) 0 ;
25875 wxSize const &arg2_defvalue = wxDefaultSize ;
25876 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25877 wxSize temp2 ;
25878 PyObject * obj0 = 0 ;
25879 PyObject * obj1 = 0 ;
25880 char *kwnames[] = {
25881 (char *) "self",(char *) "size", NULL
25882 };
25883
25884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25886 if (SWIG_arg_fail(1)) SWIG_fail;
25887 if (obj1) {
25888 {
25889 arg2 = &temp2;
25890 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25891 }
25892 }
25893 {
25894 PyThreadState* __tstate = wxPyBeginAllowThreads();
25895 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25896
25897 wxPyEndAllowThreads(__tstate);
25898 if (PyErr_Occurred()) SWIG_fail;
25899 }
25900 Py_INCREF(Py_None); resultobj = Py_None;
25901 return resultobj;
25902 fail:
25903 return NULL;
25904 }
25905
25906
25907 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25908 PyObject *resultobj;
25909 wxWindow *arg1 = (wxWindow *) 0 ;
25910 PyObject * obj0 = 0 ;
25911 char *kwnames[] = {
25912 (char *) "self", NULL
25913 };
25914
25915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25917 if (SWIG_arg_fail(1)) SWIG_fail;
25918 {
25919 PyThreadState* __tstate = wxPyBeginAllowThreads();
25920 (arg1)->Raise();
25921
25922 wxPyEndAllowThreads(__tstate);
25923 if (PyErr_Occurred()) SWIG_fail;
25924 }
25925 Py_INCREF(Py_None); resultobj = Py_None;
25926 return resultobj;
25927 fail:
25928 return NULL;
25929 }
25930
25931
25932 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25933 PyObject *resultobj;
25934 wxWindow *arg1 = (wxWindow *) 0 ;
25935 PyObject * obj0 = 0 ;
25936 char *kwnames[] = {
25937 (char *) "self", NULL
25938 };
25939
25940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25942 if (SWIG_arg_fail(1)) SWIG_fail;
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 (arg1)->Lower();
25946
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 Py_INCREF(Py_None); resultobj = Py_None;
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25958 PyObject *resultobj;
25959 wxWindow *arg1 = (wxWindow *) 0 ;
25960 wxSize *arg2 = 0 ;
25961 wxSize temp2 ;
25962 PyObject * obj0 = 0 ;
25963 PyObject * obj1 = 0 ;
25964 char *kwnames[] = {
25965 (char *) "self",(char *) "size", NULL
25966 };
25967
25968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25970 if (SWIG_arg_fail(1)) SWIG_fail;
25971 {
25972 arg2 = &temp2;
25973 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25974 }
25975 {
25976 PyThreadState* __tstate = wxPyBeginAllowThreads();
25977 (arg1)->SetClientSize((wxSize const &)*arg2);
25978
25979 wxPyEndAllowThreads(__tstate);
25980 if (PyErr_Occurred()) SWIG_fail;
25981 }
25982 Py_INCREF(Py_None); resultobj = Py_None;
25983 return resultobj;
25984 fail:
25985 return NULL;
25986 }
25987
25988
25989 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25990 PyObject *resultobj;
25991 wxWindow *arg1 = (wxWindow *) 0 ;
25992 int arg2 ;
25993 int arg3 ;
25994 PyObject * obj0 = 0 ;
25995 PyObject * obj1 = 0 ;
25996 PyObject * obj2 = 0 ;
25997 char *kwnames[] = {
25998 (char *) "self",(char *) "width",(char *) "height", NULL
25999 };
26000
26001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26003 if (SWIG_arg_fail(1)) SWIG_fail;
26004 {
26005 arg2 = (int)(SWIG_As_int(obj1));
26006 if (SWIG_arg_fail(2)) SWIG_fail;
26007 }
26008 {
26009 arg3 = (int)(SWIG_As_int(obj2));
26010 if (SWIG_arg_fail(3)) SWIG_fail;
26011 }
26012 {
26013 PyThreadState* __tstate = wxPyBeginAllowThreads();
26014 (arg1)->SetClientSize(arg2,arg3);
26015
26016 wxPyEndAllowThreads(__tstate);
26017 if (PyErr_Occurred()) SWIG_fail;
26018 }
26019 Py_INCREF(Py_None); resultobj = Py_None;
26020 return resultobj;
26021 fail:
26022 return NULL;
26023 }
26024
26025
26026 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26027 PyObject *resultobj;
26028 wxWindow *arg1 = (wxWindow *) 0 ;
26029 wxRect *arg2 = 0 ;
26030 wxRect temp2 ;
26031 PyObject * obj0 = 0 ;
26032 PyObject * obj1 = 0 ;
26033 char *kwnames[] = {
26034 (char *) "self",(char *) "rect", NULL
26035 };
26036
26037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26039 if (SWIG_arg_fail(1)) SWIG_fail;
26040 {
26041 arg2 = &temp2;
26042 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26043 }
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 (arg1)->SetClientSize((wxRect const &)*arg2);
26047
26048 wxPyEndAllowThreads(__tstate);
26049 if (PyErr_Occurred()) SWIG_fail;
26050 }
26051 Py_INCREF(Py_None); resultobj = Py_None;
26052 return resultobj;
26053 fail:
26054 return NULL;
26055 }
26056
26057
26058 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26059 PyObject *resultobj;
26060 wxWindow *arg1 = (wxWindow *) 0 ;
26061 wxPoint result;
26062 PyObject * obj0 = 0 ;
26063 char *kwnames[] = {
26064 (char *) "self", NULL
26065 };
26066
26067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26069 if (SWIG_arg_fail(1)) SWIG_fail;
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 result = (arg1)->GetPosition();
26073
26074 wxPyEndAllowThreads(__tstate);
26075 if (PyErr_Occurred()) SWIG_fail;
26076 }
26077 {
26078 wxPoint * resultptr;
26079 resultptr = new wxPoint((wxPoint &)(result));
26080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26081 }
26082 return resultobj;
26083 fail:
26084 return NULL;
26085 }
26086
26087
26088 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26089 PyObject *resultobj;
26090 wxWindow *arg1 = (wxWindow *) 0 ;
26091 int *arg2 = (int *) 0 ;
26092 int *arg3 = (int *) 0 ;
26093 int temp2 ;
26094 int res2 = 0 ;
26095 int temp3 ;
26096 int res3 = 0 ;
26097 PyObject * obj0 = 0 ;
26098 char *kwnames[] = {
26099 (char *) "self", NULL
26100 };
26101
26102 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26103 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26106 if (SWIG_arg_fail(1)) SWIG_fail;
26107 {
26108 PyThreadState* __tstate = wxPyBeginAllowThreads();
26109 (arg1)->GetPosition(arg2,arg3);
26110
26111 wxPyEndAllowThreads(__tstate);
26112 if (PyErr_Occurred()) SWIG_fail;
26113 }
26114 Py_INCREF(Py_None); resultobj = Py_None;
26115 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26116 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26117 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26118 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26126 PyObject *resultobj;
26127 wxWindow *arg1 = (wxWindow *) 0 ;
26128 wxSize result;
26129 PyObject * obj0 = 0 ;
26130 char *kwnames[] = {
26131 (char *) "self", NULL
26132 };
26133
26134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26136 if (SWIG_arg_fail(1)) SWIG_fail;
26137 {
26138 PyThreadState* __tstate = wxPyBeginAllowThreads();
26139 result = ((wxWindow const *)arg1)->GetSize();
26140
26141 wxPyEndAllowThreads(__tstate);
26142 if (PyErr_Occurred()) SWIG_fail;
26143 }
26144 {
26145 wxSize * resultptr;
26146 resultptr = new wxSize((wxSize &)(result));
26147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26148 }
26149 return resultobj;
26150 fail:
26151 return NULL;
26152 }
26153
26154
26155 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26156 PyObject *resultobj;
26157 wxWindow *arg1 = (wxWindow *) 0 ;
26158 int *arg2 = (int *) 0 ;
26159 int *arg3 = (int *) 0 ;
26160 int temp2 ;
26161 int res2 = 0 ;
26162 int temp3 ;
26163 int res3 = 0 ;
26164 PyObject * obj0 = 0 ;
26165 char *kwnames[] = {
26166 (char *) "self", NULL
26167 };
26168
26169 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26170 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26173 if (SWIG_arg_fail(1)) SWIG_fail;
26174 {
26175 PyThreadState* __tstate = wxPyBeginAllowThreads();
26176 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26177
26178 wxPyEndAllowThreads(__tstate);
26179 if (PyErr_Occurred()) SWIG_fail;
26180 }
26181 Py_INCREF(Py_None); resultobj = Py_None;
26182 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26183 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26184 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26185 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26186 return resultobj;
26187 fail:
26188 return NULL;
26189 }
26190
26191
26192 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26193 PyObject *resultobj;
26194 wxWindow *arg1 = (wxWindow *) 0 ;
26195 wxRect result;
26196 PyObject * obj0 = 0 ;
26197 char *kwnames[] = {
26198 (char *) "self", NULL
26199 };
26200
26201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26203 if (SWIG_arg_fail(1)) SWIG_fail;
26204 {
26205 PyThreadState* __tstate = wxPyBeginAllowThreads();
26206 result = ((wxWindow const *)arg1)->GetRect();
26207
26208 wxPyEndAllowThreads(__tstate);
26209 if (PyErr_Occurred()) SWIG_fail;
26210 }
26211 {
26212 wxRect * resultptr;
26213 resultptr = new wxRect((wxRect &)(result));
26214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26215 }
26216 return resultobj;
26217 fail:
26218 return NULL;
26219 }
26220
26221
26222 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26223 PyObject *resultobj;
26224 wxWindow *arg1 = (wxWindow *) 0 ;
26225 wxSize result;
26226 PyObject * obj0 = 0 ;
26227 char *kwnames[] = {
26228 (char *) "self", NULL
26229 };
26230
26231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26233 if (SWIG_arg_fail(1)) SWIG_fail;
26234 {
26235 PyThreadState* __tstate = wxPyBeginAllowThreads();
26236 result = ((wxWindow const *)arg1)->GetClientSize();
26237
26238 wxPyEndAllowThreads(__tstate);
26239 if (PyErr_Occurred()) SWIG_fail;
26240 }
26241 {
26242 wxSize * resultptr;
26243 resultptr = new wxSize((wxSize &)(result));
26244 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26245 }
26246 return resultobj;
26247 fail:
26248 return NULL;
26249 }
26250
26251
26252 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26253 PyObject *resultobj;
26254 wxWindow *arg1 = (wxWindow *) 0 ;
26255 int *arg2 = (int *) 0 ;
26256 int *arg3 = (int *) 0 ;
26257 int temp2 ;
26258 int res2 = 0 ;
26259 int temp3 ;
26260 int res3 = 0 ;
26261 PyObject * obj0 = 0 ;
26262 char *kwnames[] = {
26263 (char *) "self", NULL
26264 };
26265
26266 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26267 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26270 if (SWIG_arg_fail(1)) SWIG_fail;
26271 {
26272 PyThreadState* __tstate = wxPyBeginAllowThreads();
26273 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26274
26275 wxPyEndAllowThreads(__tstate);
26276 if (PyErr_Occurred()) SWIG_fail;
26277 }
26278 Py_INCREF(Py_None); resultobj = Py_None;
26279 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26280 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26281 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26282 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26290 PyObject *resultobj;
26291 wxWindow *arg1 = (wxWindow *) 0 ;
26292 wxPoint result;
26293 PyObject * obj0 = 0 ;
26294 char *kwnames[] = {
26295 (char *) "self", NULL
26296 };
26297
26298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26300 if (SWIG_arg_fail(1)) SWIG_fail;
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26304
26305 wxPyEndAllowThreads(__tstate);
26306 if (PyErr_Occurred()) SWIG_fail;
26307 }
26308 {
26309 wxPoint * resultptr;
26310 resultptr = new wxPoint((wxPoint &)(result));
26311 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26312 }
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26320 PyObject *resultobj;
26321 wxWindow *arg1 = (wxWindow *) 0 ;
26322 wxRect result;
26323 PyObject * obj0 = 0 ;
26324 char *kwnames[] = {
26325 (char *) "self", NULL
26326 };
26327
26328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26330 if (SWIG_arg_fail(1)) SWIG_fail;
26331 {
26332 PyThreadState* __tstate = wxPyBeginAllowThreads();
26333 result = ((wxWindow const *)arg1)->GetClientRect();
26334
26335 wxPyEndAllowThreads(__tstate);
26336 if (PyErr_Occurred()) SWIG_fail;
26337 }
26338 {
26339 wxRect * resultptr;
26340 resultptr = new wxRect((wxRect &)(result));
26341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26342 }
26343 return resultobj;
26344 fail:
26345 return NULL;
26346 }
26347
26348
26349 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26350 PyObject *resultobj;
26351 wxWindow *arg1 = (wxWindow *) 0 ;
26352 wxSize result;
26353 PyObject * obj0 = 0 ;
26354 char *kwnames[] = {
26355 (char *) "self", NULL
26356 };
26357
26358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26360 if (SWIG_arg_fail(1)) SWIG_fail;
26361 {
26362 PyThreadState* __tstate = wxPyBeginAllowThreads();
26363 result = ((wxWindow const *)arg1)->GetBestSize();
26364
26365 wxPyEndAllowThreads(__tstate);
26366 if (PyErr_Occurred()) SWIG_fail;
26367 }
26368 {
26369 wxSize * resultptr;
26370 resultptr = new wxSize((wxSize &)(result));
26371 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26372 }
26373 return resultobj;
26374 fail:
26375 return NULL;
26376 }
26377
26378
26379 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26380 PyObject *resultobj;
26381 wxWindow *arg1 = (wxWindow *) 0 ;
26382 int *arg2 = (int *) 0 ;
26383 int *arg3 = (int *) 0 ;
26384 int temp2 ;
26385 int res2 = 0 ;
26386 int temp3 ;
26387 int res3 = 0 ;
26388 PyObject * obj0 = 0 ;
26389 char *kwnames[] = {
26390 (char *) "self", NULL
26391 };
26392
26393 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26394 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26397 if (SWIG_arg_fail(1)) SWIG_fail;
26398 {
26399 PyThreadState* __tstate = wxPyBeginAllowThreads();
26400 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26401
26402 wxPyEndAllowThreads(__tstate);
26403 if (PyErr_Occurred()) SWIG_fail;
26404 }
26405 Py_INCREF(Py_None); resultobj = Py_None;
26406 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26407 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26408 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26409 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26410 return resultobj;
26411 fail:
26412 return NULL;
26413 }
26414
26415
26416 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26417 PyObject *resultobj;
26418 wxWindow *arg1 = (wxWindow *) 0 ;
26419 PyObject * obj0 = 0 ;
26420 char *kwnames[] = {
26421 (char *) "self", NULL
26422 };
26423
26424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26426 if (SWIG_arg_fail(1)) SWIG_fail;
26427 {
26428 PyThreadState* __tstate = wxPyBeginAllowThreads();
26429 (arg1)->InvalidateBestSize();
26430
26431 wxPyEndAllowThreads(__tstate);
26432 if (PyErr_Occurred()) SWIG_fail;
26433 }
26434 Py_INCREF(Py_None); resultobj = Py_None;
26435 return resultobj;
26436 fail:
26437 return NULL;
26438 }
26439
26440
26441 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26442 PyObject *resultobj;
26443 wxWindow *arg1 = (wxWindow *) 0 ;
26444 wxSize result;
26445 PyObject * obj0 = 0 ;
26446 char *kwnames[] = {
26447 (char *) "self", NULL
26448 };
26449
26450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26452 if (SWIG_arg_fail(1)) SWIG_fail;
26453 {
26454 PyThreadState* __tstate = wxPyBeginAllowThreads();
26455 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26456
26457 wxPyEndAllowThreads(__tstate);
26458 if (PyErr_Occurred()) SWIG_fail;
26459 }
26460 {
26461 wxSize * resultptr;
26462 resultptr = new wxSize((wxSize &)(result));
26463 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26464 }
26465 return resultobj;
26466 fail:
26467 return NULL;
26468 }
26469
26470
26471 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26472 PyObject *resultobj;
26473 wxWindow *arg1 = (wxWindow *) 0 ;
26474 wxSize result;
26475 PyObject * obj0 = 0 ;
26476 char *kwnames[] = {
26477 (char *) "self", NULL
26478 };
26479
26480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26482 if (SWIG_arg_fail(1)) SWIG_fail;
26483 {
26484 PyThreadState* __tstate = wxPyBeginAllowThreads();
26485 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26486
26487 wxPyEndAllowThreads(__tstate);
26488 if (PyErr_Occurred()) SWIG_fail;
26489 }
26490 {
26491 wxSize * resultptr;
26492 resultptr = new wxSize((wxSize &)(result));
26493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26494 }
26495 return resultobj;
26496 fail:
26497 return NULL;
26498 }
26499
26500
26501 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26502 PyObject *resultobj;
26503 wxWindow *arg1 = (wxWindow *) 0 ;
26504 int arg2 = (int) wxBOTH ;
26505 PyObject * obj0 = 0 ;
26506 PyObject * obj1 = 0 ;
26507 char *kwnames[] = {
26508 (char *) "self",(char *) "direction", NULL
26509 };
26510
26511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26513 if (SWIG_arg_fail(1)) SWIG_fail;
26514 if (obj1) {
26515 {
26516 arg2 = (int)(SWIG_As_int(obj1));
26517 if (SWIG_arg_fail(2)) SWIG_fail;
26518 }
26519 }
26520 {
26521 PyThreadState* __tstate = wxPyBeginAllowThreads();
26522 (arg1)->Center(arg2);
26523
26524 wxPyEndAllowThreads(__tstate);
26525 if (PyErr_Occurred()) SWIG_fail;
26526 }
26527 Py_INCREF(Py_None); resultobj = Py_None;
26528 return resultobj;
26529 fail:
26530 return NULL;
26531 }
26532
26533
26534 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26535 PyObject *resultobj;
26536 wxWindow *arg1 = (wxWindow *) 0 ;
26537 int arg2 = (int) wxBOTH ;
26538 PyObject * obj0 = 0 ;
26539 PyObject * obj1 = 0 ;
26540 char *kwnames[] = {
26541 (char *) "self",(char *) "dir", NULL
26542 };
26543
26544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26546 if (SWIG_arg_fail(1)) SWIG_fail;
26547 if (obj1) {
26548 {
26549 arg2 = (int)(SWIG_As_int(obj1));
26550 if (SWIG_arg_fail(2)) SWIG_fail;
26551 }
26552 }
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 (arg1)->CenterOnScreen(arg2);
26556
26557 wxPyEndAllowThreads(__tstate);
26558 if (PyErr_Occurred()) SWIG_fail;
26559 }
26560 Py_INCREF(Py_None); resultobj = Py_None;
26561 return resultobj;
26562 fail:
26563 return NULL;
26564 }
26565
26566
26567 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26568 PyObject *resultobj;
26569 wxWindow *arg1 = (wxWindow *) 0 ;
26570 int arg2 = (int) wxBOTH ;
26571 PyObject * obj0 = 0 ;
26572 PyObject * obj1 = 0 ;
26573 char *kwnames[] = {
26574 (char *) "self",(char *) "dir", NULL
26575 };
26576
26577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26579 if (SWIG_arg_fail(1)) SWIG_fail;
26580 if (obj1) {
26581 {
26582 arg2 = (int)(SWIG_As_int(obj1));
26583 if (SWIG_arg_fail(2)) SWIG_fail;
26584 }
26585 }
26586 {
26587 PyThreadState* __tstate = wxPyBeginAllowThreads();
26588 (arg1)->CenterOnParent(arg2);
26589
26590 wxPyEndAllowThreads(__tstate);
26591 if (PyErr_Occurred()) SWIG_fail;
26592 }
26593 Py_INCREF(Py_None); resultobj = Py_None;
26594 return resultobj;
26595 fail:
26596 return NULL;
26597 }
26598
26599
26600 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26601 PyObject *resultobj;
26602 wxWindow *arg1 = (wxWindow *) 0 ;
26603 PyObject * obj0 = 0 ;
26604 char *kwnames[] = {
26605 (char *) "self", NULL
26606 };
26607
26608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26610 if (SWIG_arg_fail(1)) SWIG_fail;
26611 {
26612 PyThreadState* __tstate = wxPyBeginAllowThreads();
26613 (arg1)->Fit();
26614
26615 wxPyEndAllowThreads(__tstate);
26616 if (PyErr_Occurred()) SWIG_fail;
26617 }
26618 Py_INCREF(Py_None); resultobj = Py_None;
26619 return resultobj;
26620 fail:
26621 return NULL;
26622 }
26623
26624
26625 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26626 PyObject *resultobj;
26627 wxWindow *arg1 = (wxWindow *) 0 ;
26628 PyObject * obj0 = 0 ;
26629 char *kwnames[] = {
26630 (char *) "self", NULL
26631 };
26632
26633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26635 if (SWIG_arg_fail(1)) SWIG_fail;
26636 {
26637 PyThreadState* __tstate = wxPyBeginAllowThreads();
26638 (arg1)->FitInside();
26639
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 Py_INCREF(Py_None); resultobj = Py_None;
26644 return resultobj;
26645 fail:
26646 return NULL;
26647 }
26648
26649
26650 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26651 PyObject *resultobj;
26652 wxWindow *arg1 = (wxWindow *) 0 ;
26653 int arg2 ;
26654 int arg3 ;
26655 int arg4 = (int) -1 ;
26656 int arg5 = (int) -1 ;
26657 int arg6 = (int) -1 ;
26658 int arg7 = (int) -1 ;
26659 PyObject * obj0 = 0 ;
26660 PyObject * obj1 = 0 ;
26661 PyObject * obj2 = 0 ;
26662 PyObject * obj3 = 0 ;
26663 PyObject * obj4 = 0 ;
26664 PyObject * obj5 = 0 ;
26665 PyObject * obj6 = 0 ;
26666 char *kwnames[] = {
26667 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26668 };
26669
26670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26672 if (SWIG_arg_fail(1)) SWIG_fail;
26673 {
26674 arg2 = (int)(SWIG_As_int(obj1));
26675 if (SWIG_arg_fail(2)) SWIG_fail;
26676 }
26677 {
26678 arg3 = (int)(SWIG_As_int(obj2));
26679 if (SWIG_arg_fail(3)) SWIG_fail;
26680 }
26681 if (obj3) {
26682 {
26683 arg4 = (int)(SWIG_As_int(obj3));
26684 if (SWIG_arg_fail(4)) SWIG_fail;
26685 }
26686 }
26687 if (obj4) {
26688 {
26689 arg5 = (int)(SWIG_As_int(obj4));
26690 if (SWIG_arg_fail(5)) SWIG_fail;
26691 }
26692 }
26693 if (obj5) {
26694 {
26695 arg6 = (int)(SWIG_As_int(obj5));
26696 if (SWIG_arg_fail(6)) SWIG_fail;
26697 }
26698 }
26699 if (obj6) {
26700 {
26701 arg7 = (int)(SWIG_As_int(obj6));
26702 if (SWIG_arg_fail(7)) SWIG_fail;
26703 }
26704 }
26705 {
26706 PyThreadState* __tstate = wxPyBeginAllowThreads();
26707 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26708
26709 wxPyEndAllowThreads(__tstate);
26710 if (PyErr_Occurred()) SWIG_fail;
26711 }
26712 Py_INCREF(Py_None); resultobj = Py_None;
26713 return resultobj;
26714 fail:
26715 return NULL;
26716 }
26717
26718
26719 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26720 PyObject *resultobj;
26721 wxWindow *arg1 = (wxWindow *) 0 ;
26722 wxSize *arg2 = 0 ;
26723 wxSize const &arg3_defvalue = wxDefaultSize ;
26724 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26725 wxSize const &arg4_defvalue = wxDefaultSize ;
26726 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26727 wxSize temp2 ;
26728 wxSize temp3 ;
26729 wxSize temp4 ;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732 PyObject * obj2 = 0 ;
26733 PyObject * obj3 = 0 ;
26734 char *kwnames[] = {
26735 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26736 };
26737
26738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26740 if (SWIG_arg_fail(1)) SWIG_fail;
26741 {
26742 arg2 = &temp2;
26743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26744 }
26745 if (obj2) {
26746 {
26747 arg3 = &temp3;
26748 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26749 }
26750 }
26751 if (obj3) {
26752 {
26753 arg4 = &temp4;
26754 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26755 }
26756 }
26757 {
26758 PyThreadState* __tstate = wxPyBeginAllowThreads();
26759 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26760
26761 wxPyEndAllowThreads(__tstate);
26762 if (PyErr_Occurred()) SWIG_fail;
26763 }
26764 Py_INCREF(Py_None); resultobj = Py_None;
26765 return resultobj;
26766 fail:
26767 return NULL;
26768 }
26769
26770
26771 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26772 PyObject *resultobj;
26773 wxWindow *arg1 = (wxWindow *) 0 ;
26774 int arg2 ;
26775 int arg3 ;
26776 int arg4 = (int) -1 ;
26777 int arg5 = (int) -1 ;
26778 PyObject * obj0 = 0 ;
26779 PyObject * obj1 = 0 ;
26780 PyObject * obj2 = 0 ;
26781 PyObject * obj3 = 0 ;
26782 PyObject * obj4 = 0 ;
26783 char *kwnames[] = {
26784 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26785 };
26786
26787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26789 if (SWIG_arg_fail(1)) SWIG_fail;
26790 {
26791 arg2 = (int)(SWIG_As_int(obj1));
26792 if (SWIG_arg_fail(2)) SWIG_fail;
26793 }
26794 {
26795 arg3 = (int)(SWIG_As_int(obj2));
26796 if (SWIG_arg_fail(3)) SWIG_fail;
26797 }
26798 if (obj3) {
26799 {
26800 arg4 = (int)(SWIG_As_int(obj3));
26801 if (SWIG_arg_fail(4)) SWIG_fail;
26802 }
26803 }
26804 if (obj4) {
26805 {
26806 arg5 = (int)(SWIG_As_int(obj4));
26807 if (SWIG_arg_fail(5)) SWIG_fail;
26808 }
26809 }
26810 {
26811 PyThreadState* __tstate = wxPyBeginAllowThreads();
26812 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26813
26814 wxPyEndAllowThreads(__tstate);
26815 if (PyErr_Occurred()) SWIG_fail;
26816 }
26817 Py_INCREF(Py_None); resultobj = Py_None;
26818 return resultobj;
26819 fail:
26820 return NULL;
26821 }
26822
26823
26824 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26825 PyObject *resultobj;
26826 wxWindow *arg1 = (wxWindow *) 0 ;
26827 wxSize *arg2 = 0 ;
26828 wxSize const &arg3_defvalue = wxDefaultSize ;
26829 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26830 wxSize temp2 ;
26831 wxSize temp3 ;
26832 PyObject * obj0 = 0 ;
26833 PyObject * obj1 = 0 ;
26834 PyObject * obj2 = 0 ;
26835 char *kwnames[] = {
26836 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26837 };
26838
26839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26841 if (SWIG_arg_fail(1)) SWIG_fail;
26842 {
26843 arg2 = &temp2;
26844 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26845 }
26846 if (obj2) {
26847 {
26848 arg3 = &temp3;
26849 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26850 }
26851 }
26852 {
26853 PyThreadState* __tstate = wxPyBeginAllowThreads();
26854 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26855
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 Py_INCREF(Py_None); resultobj = Py_None;
26860 return resultobj;
26861 fail:
26862 return NULL;
26863 }
26864
26865
26866 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26867 PyObject *resultobj;
26868 wxWindow *arg1 = (wxWindow *) 0 ;
26869 wxSize result;
26870 PyObject * obj0 = 0 ;
26871 char *kwnames[] = {
26872 (char *) "self", NULL
26873 };
26874
26875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26877 if (SWIG_arg_fail(1)) SWIG_fail;
26878 {
26879 PyThreadState* __tstate = wxPyBeginAllowThreads();
26880 result = ((wxWindow const *)arg1)->GetMaxSize();
26881
26882 wxPyEndAllowThreads(__tstate);
26883 if (PyErr_Occurred()) SWIG_fail;
26884 }
26885 {
26886 wxSize * resultptr;
26887 resultptr = new wxSize((wxSize &)(result));
26888 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26889 }
26890 return resultobj;
26891 fail:
26892 return NULL;
26893 }
26894
26895
26896 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj;
26898 wxWindow *arg1 = (wxWindow *) 0 ;
26899 wxSize result;
26900 PyObject * obj0 = 0 ;
26901 char *kwnames[] = {
26902 (char *) "self", NULL
26903 };
26904
26905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26907 if (SWIG_arg_fail(1)) SWIG_fail;
26908 {
26909 PyThreadState* __tstate = wxPyBeginAllowThreads();
26910 result = ((wxWindow const *)arg1)->GetMinSize();
26911
26912 wxPyEndAllowThreads(__tstate);
26913 if (PyErr_Occurred()) SWIG_fail;
26914 }
26915 {
26916 wxSize * resultptr;
26917 resultptr = new wxSize((wxSize &)(result));
26918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26919 }
26920 return resultobj;
26921 fail:
26922 return NULL;
26923 }
26924
26925
26926 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26927 PyObject *resultobj;
26928 wxWindow *arg1 = (wxWindow *) 0 ;
26929 wxSize *arg2 = 0 ;
26930 wxSize temp2 ;
26931 PyObject * obj0 = 0 ;
26932 PyObject * obj1 = 0 ;
26933 char *kwnames[] = {
26934 (char *) "self",(char *) "minSize", NULL
26935 };
26936
26937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26939 if (SWIG_arg_fail(1)) SWIG_fail;
26940 {
26941 arg2 = &temp2;
26942 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26943 }
26944 {
26945 PyThreadState* __tstate = wxPyBeginAllowThreads();
26946 (arg1)->SetMinSize((wxSize const &)*arg2);
26947
26948 wxPyEndAllowThreads(__tstate);
26949 if (PyErr_Occurred()) SWIG_fail;
26950 }
26951 Py_INCREF(Py_None); resultobj = Py_None;
26952 return resultobj;
26953 fail:
26954 return NULL;
26955 }
26956
26957
26958 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26959 PyObject *resultobj;
26960 wxWindow *arg1 = (wxWindow *) 0 ;
26961 wxSize *arg2 = 0 ;
26962 wxSize temp2 ;
26963 PyObject * obj0 = 0 ;
26964 PyObject * obj1 = 0 ;
26965 char *kwnames[] = {
26966 (char *) "self",(char *) "maxSize", NULL
26967 };
26968
26969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26971 if (SWIG_arg_fail(1)) SWIG_fail;
26972 {
26973 arg2 = &temp2;
26974 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26975 }
26976 {
26977 PyThreadState* __tstate = wxPyBeginAllowThreads();
26978 (arg1)->SetMaxSize((wxSize const &)*arg2);
26979
26980 wxPyEndAllowThreads(__tstate);
26981 if (PyErr_Occurred()) SWIG_fail;
26982 }
26983 Py_INCREF(Py_None); resultobj = Py_None;
26984 return resultobj;
26985 fail:
26986 return NULL;
26987 }
26988
26989
26990 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26991 PyObject *resultobj;
26992 wxWindow *arg1 = (wxWindow *) 0 ;
26993 int result;
26994 PyObject * obj0 = 0 ;
26995 char *kwnames[] = {
26996 (char *) "self", NULL
26997 };
26998
26999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27001 if (SWIG_arg_fail(1)) SWIG_fail;
27002 {
27003 PyThreadState* __tstate = wxPyBeginAllowThreads();
27004 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27005
27006 wxPyEndAllowThreads(__tstate);
27007 if (PyErr_Occurred()) SWIG_fail;
27008 }
27009 {
27010 resultobj = SWIG_From_int((int)(result));
27011 }
27012 return resultobj;
27013 fail:
27014 return NULL;
27015 }
27016
27017
27018 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27019 PyObject *resultobj;
27020 wxWindow *arg1 = (wxWindow *) 0 ;
27021 int result;
27022 PyObject * obj0 = 0 ;
27023 char *kwnames[] = {
27024 (char *) "self", NULL
27025 };
27026
27027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27029 if (SWIG_arg_fail(1)) SWIG_fail;
27030 {
27031 PyThreadState* __tstate = wxPyBeginAllowThreads();
27032 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27033
27034 wxPyEndAllowThreads(__tstate);
27035 if (PyErr_Occurred()) SWIG_fail;
27036 }
27037 {
27038 resultobj = SWIG_From_int((int)(result));
27039 }
27040 return resultobj;
27041 fail:
27042 return NULL;
27043 }
27044
27045
27046 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27047 PyObject *resultobj;
27048 wxWindow *arg1 = (wxWindow *) 0 ;
27049 int result;
27050 PyObject * obj0 = 0 ;
27051 char *kwnames[] = {
27052 (char *) "self", NULL
27053 };
27054
27055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27057 if (SWIG_arg_fail(1)) SWIG_fail;
27058 {
27059 PyThreadState* __tstate = wxPyBeginAllowThreads();
27060 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27061
27062 wxPyEndAllowThreads(__tstate);
27063 if (PyErr_Occurred()) SWIG_fail;
27064 }
27065 {
27066 resultobj = SWIG_From_int((int)(result));
27067 }
27068 return resultobj;
27069 fail:
27070 return NULL;
27071 }
27072
27073
27074 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27075 PyObject *resultobj;
27076 wxWindow *arg1 = (wxWindow *) 0 ;
27077 int result;
27078 PyObject * obj0 = 0 ;
27079 char *kwnames[] = {
27080 (char *) "self", NULL
27081 };
27082
27083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27085 if (SWIG_arg_fail(1)) SWIG_fail;
27086 {
27087 PyThreadState* __tstate = wxPyBeginAllowThreads();
27088 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27089
27090 wxPyEndAllowThreads(__tstate);
27091 if (PyErr_Occurred()) SWIG_fail;
27092 }
27093 {
27094 resultobj = SWIG_From_int((int)(result));
27095 }
27096 return resultobj;
27097 fail:
27098 return NULL;
27099 }
27100
27101
27102 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27103 PyObject *resultobj;
27104 wxWindow *arg1 = (wxWindow *) 0 ;
27105 wxSize *arg2 = 0 ;
27106 wxSize temp2 ;
27107 PyObject * obj0 = 0 ;
27108 PyObject * obj1 = 0 ;
27109 char *kwnames[] = {
27110 (char *) "self",(char *) "size", NULL
27111 };
27112
27113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27115 if (SWIG_arg_fail(1)) SWIG_fail;
27116 {
27117 arg2 = &temp2;
27118 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27119 }
27120 {
27121 PyThreadState* __tstate = wxPyBeginAllowThreads();
27122 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27123
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 Py_INCREF(Py_None); resultobj = Py_None;
27128 return resultobj;
27129 fail:
27130 return NULL;
27131 }
27132
27133
27134 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27135 PyObject *resultobj;
27136 wxWindow *arg1 = (wxWindow *) 0 ;
27137 int arg2 ;
27138 int arg3 ;
27139 PyObject * obj0 = 0 ;
27140 PyObject * obj1 = 0 ;
27141 PyObject * obj2 = 0 ;
27142 char *kwnames[] = {
27143 (char *) "self",(char *) "w",(char *) "h", NULL
27144 };
27145
27146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27148 if (SWIG_arg_fail(1)) SWIG_fail;
27149 {
27150 arg2 = (int)(SWIG_As_int(obj1));
27151 if (SWIG_arg_fail(2)) SWIG_fail;
27152 }
27153 {
27154 arg3 = (int)(SWIG_As_int(obj2));
27155 if (SWIG_arg_fail(3)) SWIG_fail;
27156 }
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 (arg1)->SetVirtualSize(arg2,arg3);
27160
27161 wxPyEndAllowThreads(__tstate);
27162 if (PyErr_Occurred()) SWIG_fail;
27163 }
27164 Py_INCREF(Py_None); resultobj = Py_None;
27165 return resultobj;
27166 fail:
27167 return NULL;
27168 }
27169
27170
27171 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27172 PyObject *resultobj;
27173 wxWindow *arg1 = (wxWindow *) 0 ;
27174 wxSize result;
27175 PyObject * obj0 = 0 ;
27176 char *kwnames[] = {
27177 (char *) "self", NULL
27178 };
27179
27180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27182 if (SWIG_arg_fail(1)) SWIG_fail;
27183 {
27184 PyThreadState* __tstate = wxPyBeginAllowThreads();
27185 result = ((wxWindow const *)arg1)->GetVirtualSize();
27186
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 {
27191 wxSize * resultptr;
27192 resultptr = new wxSize((wxSize &)(result));
27193 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27194 }
27195 return resultobj;
27196 fail:
27197 return NULL;
27198 }
27199
27200
27201 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27202 PyObject *resultobj;
27203 wxWindow *arg1 = (wxWindow *) 0 ;
27204 int *arg2 = (int *) 0 ;
27205 int *arg3 = (int *) 0 ;
27206 int temp2 ;
27207 int res2 = 0 ;
27208 int temp3 ;
27209 int res3 = 0 ;
27210 PyObject * obj0 = 0 ;
27211 char *kwnames[] = {
27212 (char *) "self", NULL
27213 };
27214
27215 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27216 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27219 if (SWIG_arg_fail(1)) SWIG_fail;
27220 {
27221 PyThreadState* __tstate = wxPyBeginAllowThreads();
27222 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27223
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 Py_INCREF(Py_None); resultobj = Py_None;
27228 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27229 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27230 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27231 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27239 PyObject *resultobj;
27240 wxWindow *arg1 = (wxWindow *) 0 ;
27241 wxSize result;
27242 PyObject * obj0 = 0 ;
27243 char *kwnames[] = {
27244 (char *) "self", NULL
27245 };
27246
27247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27249 if (SWIG_arg_fail(1)) SWIG_fail;
27250 {
27251 PyThreadState* __tstate = wxPyBeginAllowThreads();
27252 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27253
27254 wxPyEndAllowThreads(__tstate);
27255 if (PyErr_Occurred()) SWIG_fail;
27256 }
27257 {
27258 wxSize * resultptr;
27259 resultptr = new wxSize((wxSize &)(result));
27260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27261 }
27262 return resultobj;
27263 fail:
27264 return NULL;
27265 }
27266
27267
27268 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27269 PyObject *resultobj;
27270 wxWindow *arg1 = (wxWindow *) 0 ;
27271 bool arg2 = (bool) true ;
27272 bool result;
27273 PyObject * obj0 = 0 ;
27274 PyObject * obj1 = 0 ;
27275 char *kwnames[] = {
27276 (char *) "self",(char *) "show", NULL
27277 };
27278
27279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27281 if (SWIG_arg_fail(1)) SWIG_fail;
27282 if (obj1) {
27283 {
27284 arg2 = (bool)(SWIG_As_bool(obj1));
27285 if (SWIG_arg_fail(2)) SWIG_fail;
27286 }
27287 }
27288 {
27289 PyThreadState* __tstate = wxPyBeginAllowThreads();
27290 result = (bool)(arg1)->Show(arg2);
27291
27292 wxPyEndAllowThreads(__tstate);
27293 if (PyErr_Occurred()) SWIG_fail;
27294 }
27295 {
27296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27297 }
27298 return resultobj;
27299 fail:
27300 return NULL;
27301 }
27302
27303
27304 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27305 PyObject *resultobj;
27306 wxWindow *arg1 = (wxWindow *) 0 ;
27307 bool result;
27308 PyObject * obj0 = 0 ;
27309 char *kwnames[] = {
27310 (char *) "self", NULL
27311 };
27312
27313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27315 if (SWIG_arg_fail(1)) SWIG_fail;
27316 {
27317 PyThreadState* __tstate = wxPyBeginAllowThreads();
27318 result = (bool)(arg1)->Hide();
27319
27320 wxPyEndAllowThreads(__tstate);
27321 if (PyErr_Occurred()) SWIG_fail;
27322 }
27323 {
27324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27325 }
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27333 PyObject *resultobj;
27334 wxWindow *arg1 = (wxWindow *) 0 ;
27335 bool arg2 = (bool) true ;
27336 bool result;
27337 PyObject * obj0 = 0 ;
27338 PyObject * obj1 = 0 ;
27339 char *kwnames[] = {
27340 (char *) "self",(char *) "enable", NULL
27341 };
27342
27343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27345 if (SWIG_arg_fail(1)) SWIG_fail;
27346 if (obj1) {
27347 {
27348 arg2 = (bool)(SWIG_As_bool(obj1));
27349 if (SWIG_arg_fail(2)) SWIG_fail;
27350 }
27351 }
27352 {
27353 PyThreadState* __tstate = wxPyBeginAllowThreads();
27354 result = (bool)(arg1)->Enable(arg2);
27355
27356 wxPyEndAllowThreads(__tstate);
27357 if (PyErr_Occurred()) SWIG_fail;
27358 }
27359 {
27360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27361 }
27362 return resultobj;
27363 fail:
27364 return NULL;
27365 }
27366
27367
27368 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27369 PyObject *resultobj;
27370 wxWindow *arg1 = (wxWindow *) 0 ;
27371 bool result;
27372 PyObject * obj0 = 0 ;
27373 char *kwnames[] = {
27374 (char *) "self", NULL
27375 };
27376
27377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27379 if (SWIG_arg_fail(1)) SWIG_fail;
27380 {
27381 PyThreadState* __tstate = wxPyBeginAllowThreads();
27382 result = (bool)(arg1)->Disable();
27383
27384 wxPyEndAllowThreads(__tstate);
27385 if (PyErr_Occurred()) SWIG_fail;
27386 }
27387 {
27388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27389 }
27390 return resultobj;
27391 fail:
27392 return NULL;
27393 }
27394
27395
27396 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27397 PyObject *resultobj;
27398 wxWindow *arg1 = (wxWindow *) 0 ;
27399 bool result;
27400 PyObject * obj0 = 0 ;
27401 char *kwnames[] = {
27402 (char *) "self", NULL
27403 };
27404
27405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27407 if (SWIG_arg_fail(1)) SWIG_fail;
27408 {
27409 PyThreadState* __tstate = wxPyBeginAllowThreads();
27410 result = (bool)((wxWindow const *)arg1)->IsShown();
27411
27412 wxPyEndAllowThreads(__tstate);
27413 if (PyErr_Occurred()) SWIG_fail;
27414 }
27415 {
27416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27417 }
27418 return resultobj;
27419 fail:
27420 return NULL;
27421 }
27422
27423
27424 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27425 PyObject *resultobj;
27426 wxWindow *arg1 = (wxWindow *) 0 ;
27427 bool result;
27428 PyObject * obj0 = 0 ;
27429 char *kwnames[] = {
27430 (char *) "self", NULL
27431 };
27432
27433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27435 if (SWIG_arg_fail(1)) SWIG_fail;
27436 {
27437 PyThreadState* __tstate = wxPyBeginAllowThreads();
27438 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27439
27440 wxPyEndAllowThreads(__tstate);
27441 if (PyErr_Occurred()) SWIG_fail;
27442 }
27443 {
27444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27445 }
27446 return resultobj;
27447 fail:
27448 return NULL;
27449 }
27450
27451
27452 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27453 PyObject *resultobj;
27454 wxWindow *arg1 = (wxWindow *) 0 ;
27455 long arg2 ;
27456 PyObject * obj0 = 0 ;
27457 PyObject * obj1 = 0 ;
27458 char *kwnames[] = {
27459 (char *) "self",(char *) "style", NULL
27460 };
27461
27462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27464 if (SWIG_arg_fail(1)) SWIG_fail;
27465 {
27466 arg2 = (long)(SWIG_As_long(obj1));
27467 if (SWIG_arg_fail(2)) SWIG_fail;
27468 }
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 (arg1)->SetWindowStyleFlag(arg2);
27472
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 Py_INCREF(Py_None); resultobj = Py_None;
27477 return resultobj;
27478 fail:
27479 return NULL;
27480 }
27481
27482
27483 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27484 PyObject *resultobj;
27485 wxWindow *arg1 = (wxWindow *) 0 ;
27486 long result;
27487 PyObject * obj0 = 0 ;
27488 char *kwnames[] = {
27489 (char *) "self", NULL
27490 };
27491
27492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27494 if (SWIG_arg_fail(1)) SWIG_fail;
27495 {
27496 PyThreadState* __tstate = wxPyBeginAllowThreads();
27497 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27498
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 {
27503 resultobj = SWIG_From_long((long)(result));
27504 }
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27512 PyObject *resultobj;
27513 wxWindow *arg1 = (wxWindow *) 0 ;
27514 int arg2 ;
27515 bool result;
27516 PyObject * obj0 = 0 ;
27517 PyObject * obj1 = 0 ;
27518 char *kwnames[] = {
27519 (char *) "self",(char *) "flag", NULL
27520 };
27521
27522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27524 if (SWIG_arg_fail(1)) SWIG_fail;
27525 {
27526 arg2 = (int)(SWIG_As_int(obj1));
27527 if (SWIG_arg_fail(2)) SWIG_fail;
27528 }
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27532
27533 wxPyEndAllowThreads(__tstate);
27534 if (PyErr_Occurred()) SWIG_fail;
27535 }
27536 {
27537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27538 }
27539 return resultobj;
27540 fail:
27541 return NULL;
27542 }
27543
27544
27545 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27546 PyObject *resultobj;
27547 wxWindow *arg1 = (wxWindow *) 0 ;
27548 bool result;
27549 PyObject * obj0 = 0 ;
27550 char *kwnames[] = {
27551 (char *) "self", NULL
27552 };
27553
27554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27556 if (SWIG_arg_fail(1)) SWIG_fail;
27557 {
27558 PyThreadState* __tstate = wxPyBeginAllowThreads();
27559 result = (bool)((wxWindow const *)arg1)->IsRetained();
27560
27561 wxPyEndAllowThreads(__tstate);
27562 if (PyErr_Occurred()) SWIG_fail;
27563 }
27564 {
27565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27566 }
27567 return resultobj;
27568 fail:
27569 return NULL;
27570 }
27571
27572
27573 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27574 PyObject *resultobj;
27575 wxWindow *arg1 = (wxWindow *) 0 ;
27576 long arg2 ;
27577 PyObject * obj0 = 0 ;
27578 PyObject * obj1 = 0 ;
27579 char *kwnames[] = {
27580 (char *) "self",(char *) "exStyle", NULL
27581 };
27582
27583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27585 if (SWIG_arg_fail(1)) SWIG_fail;
27586 {
27587 arg2 = (long)(SWIG_As_long(obj1));
27588 if (SWIG_arg_fail(2)) SWIG_fail;
27589 }
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 (arg1)->SetExtraStyle(arg2);
27593
27594 wxPyEndAllowThreads(__tstate);
27595 if (PyErr_Occurred()) SWIG_fail;
27596 }
27597 Py_INCREF(Py_None); resultobj = Py_None;
27598 return resultobj;
27599 fail:
27600 return NULL;
27601 }
27602
27603
27604 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27605 PyObject *resultobj;
27606 wxWindow *arg1 = (wxWindow *) 0 ;
27607 long result;
27608 PyObject * obj0 = 0 ;
27609 char *kwnames[] = {
27610 (char *) "self", NULL
27611 };
27612
27613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27615 if (SWIG_arg_fail(1)) SWIG_fail;
27616 {
27617 PyThreadState* __tstate = wxPyBeginAllowThreads();
27618 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27619
27620 wxPyEndAllowThreads(__tstate);
27621 if (PyErr_Occurred()) SWIG_fail;
27622 }
27623 {
27624 resultobj = SWIG_From_long((long)(result));
27625 }
27626 return resultobj;
27627 fail:
27628 return NULL;
27629 }
27630
27631
27632 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27633 PyObject *resultobj;
27634 wxWindow *arg1 = (wxWindow *) 0 ;
27635 bool arg2 = (bool) true ;
27636 PyObject * obj0 = 0 ;
27637 PyObject * obj1 = 0 ;
27638 char *kwnames[] = {
27639 (char *) "self",(char *) "modal", NULL
27640 };
27641
27642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27644 if (SWIG_arg_fail(1)) SWIG_fail;
27645 if (obj1) {
27646 {
27647 arg2 = (bool)(SWIG_As_bool(obj1));
27648 if (SWIG_arg_fail(2)) SWIG_fail;
27649 }
27650 }
27651 {
27652 PyThreadState* __tstate = wxPyBeginAllowThreads();
27653 (arg1)->MakeModal(arg2);
27654
27655 wxPyEndAllowThreads(__tstate);
27656 if (PyErr_Occurred()) SWIG_fail;
27657 }
27658 Py_INCREF(Py_None); resultobj = Py_None;
27659 return resultobj;
27660 fail:
27661 return NULL;
27662 }
27663
27664
27665 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27666 PyObject *resultobj;
27667 wxWindow *arg1 = (wxWindow *) 0 ;
27668 bool arg2 ;
27669 PyObject * obj0 = 0 ;
27670 PyObject * obj1 = 0 ;
27671 char *kwnames[] = {
27672 (char *) "self",(char *) "enableTheme", NULL
27673 };
27674
27675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27677 if (SWIG_arg_fail(1)) SWIG_fail;
27678 {
27679 arg2 = (bool)(SWIG_As_bool(obj1));
27680 if (SWIG_arg_fail(2)) SWIG_fail;
27681 }
27682 {
27683 PyThreadState* __tstate = wxPyBeginAllowThreads();
27684 (arg1)->SetThemeEnabled(arg2);
27685
27686 wxPyEndAllowThreads(__tstate);
27687 if (PyErr_Occurred()) SWIG_fail;
27688 }
27689 Py_INCREF(Py_None); resultobj = Py_None;
27690 return resultobj;
27691 fail:
27692 return NULL;
27693 }
27694
27695
27696 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27697 PyObject *resultobj;
27698 wxWindow *arg1 = (wxWindow *) 0 ;
27699 bool result;
27700 PyObject * obj0 = 0 ;
27701 char *kwnames[] = {
27702 (char *) "self", NULL
27703 };
27704
27705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27707 if (SWIG_arg_fail(1)) SWIG_fail;
27708 {
27709 PyThreadState* __tstate = wxPyBeginAllowThreads();
27710 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27711
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 {
27716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27717 }
27718 return resultobj;
27719 fail:
27720 return NULL;
27721 }
27722
27723
27724 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27725 PyObject *resultobj;
27726 wxWindow *arg1 = (wxWindow *) 0 ;
27727 PyObject * obj0 = 0 ;
27728 char *kwnames[] = {
27729 (char *) "self", NULL
27730 };
27731
27732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27734 if (SWIG_arg_fail(1)) SWIG_fail;
27735 {
27736 PyThreadState* __tstate = wxPyBeginAllowThreads();
27737 (arg1)->SetFocus();
27738
27739 wxPyEndAllowThreads(__tstate);
27740 if (PyErr_Occurred()) SWIG_fail;
27741 }
27742 Py_INCREF(Py_None); resultobj = Py_None;
27743 return resultobj;
27744 fail:
27745 return NULL;
27746 }
27747
27748
27749 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27750 PyObject *resultobj;
27751 wxWindow *arg1 = (wxWindow *) 0 ;
27752 PyObject * obj0 = 0 ;
27753 char *kwnames[] = {
27754 (char *) "self", NULL
27755 };
27756
27757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27759 if (SWIG_arg_fail(1)) SWIG_fail;
27760 {
27761 PyThreadState* __tstate = wxPyBeginAllowThreads();
27762 (arg1)->SetFocusFromKbd();
27763
27764 wxPyEndAllowThreads(__tstate);
27765 if (PyErr_Occurred()) SWIG_fail;
27766 }
27767 Py_INCREF(Py_None); resultobj = Py_None;
27768 return resultobj;
27769 fail:
27770 return NULL;
27771 }
27772
27773
27774 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27775 PyObject *resultobj;
27776 wxWindow *result;
27777 char *kwnames[] = {
27778 NULL
27779 };
27780
27781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27782 {
27783 if (!wxPyCheckForApp()) SWIG_fail;
27784 PyThreadState* __tstate = wxPyBeginAllowThreads();
27785 result = (wxWindow *)wxWindow::FindFocus();
27786
27787 wxPyEndAllowThreads(__tstate);
27788 if (PyErr_Occurred()) SWIG_fail;
27789 }
27790 {
27791 resultobj = wxPyMake_wxObject(result, 0);
27792 }
27793 return resultobj;
27794 fail:
27795 return NULL;
27796 }
27797
27798
27799 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27800 PyObject *resultobj;
27801 wxWindow *arg1 = (wxWindow *) 0 ;
27802 bool result;
27803 PyObject * obj0 = 0 ;
27804 char *kwnames[] = {
27805 (char *) "self", NULL
27806 };
27807
27808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27810 if (SWIG_arg_fail(1)) SWIG_fail;
27811 {
27812 PyThreadState* __tstate = wxPyBeginAllowThreads();
27813 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27814
27815 wxPyEndAllowThreads(__tstate);
27816 if (PyErr_Occurred()) SWIG_fail;
27817 }
27818 {
27819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27820 }
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27828 PyObject *resultobj;
27829 wxWindow *arg1 = (wxWindow *) 0 ;
27830 bool result;
27831 PyObject * obj0 = 0 ;
27832 char *kwnames[] = {
27833 (char *) "self", NULL
27834 };
27835
27836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27838 if (SWIG_arg_fail(1)) SWIG_fail;
27839 {
27840 PyThreadState* __tstate = wxPyBeginAllowThreads();
27841 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27842
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 {
27847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27848 }
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27856 PyObject *resultobj;
27857 wxWindow *arg1 = (wxWindow *) 0 ;
27858 wxWindow *result;
27859 PyObject * obj0 = 0 ;
27860 char *kwnames[] = {
27861 (char *) "self", NULL
27862 };
27863
27864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27866 if (SWIG_arg_fail(1)) SWIG_fail;
27867 {
27868 PyThreadState* __tstate = wxPyBeginAllowThreads();
27869 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27870
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 {
27875 resultobj = wxPyMake_wxObject(result, 0);
27876 }
27877 return resultobj;
27878 fail:
27879 return NULL;
27880 }
27881
27882
27883 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27884 PyObject *resultobj;
27885 wxWindow *arg1 = (wxWindow *) 0 ;
27886 wxWindow *arg2 = (wxWindow *) 0 ;
27887 wxWindow *result;
27888 PyObject * obj0 = 0 ;
27889 PyObject * obj1 = 0 ;
27890 char *kwnames[] = {
27891 (char *) "self",(char *) "child", NULL
27892 };
27893
27894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27896 if (SWIG_arg_fail(1)) SWIG_fail;
27897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27898 if (SWIG_arg_fail(2)) SWIG_fail;
27899 {
27900 PyThreadState* __tstate = wxPyBeginAllowThreads();
27901 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27902
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 {
27907 resultobj = wxPyMake_wxObject(result, 0);
27908 }
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27916 PyObject *resultobj;
27917 wxWindow *arg1 = (wxWindow *) 0 ;
27918 wxWindow *arg2 = (wxWindow *) 0 ;
27919 PyObject * obj0 = 0 ;
27920 PyObject * obj1 = 0 ;
27921 char *kwnames[] = {
27922 (char *) "self",(char *) "win", NULL
27923 };
27924
27925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27927 if (SWIG_arg_fail(1)) SWIG_fail;
27928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27929 if (SWIG_arg_fail(2)) SWIG_fail;
27930 {
27931 PyThreadState* __tstate = wxPyBeginAllowThreads();
27932 (arg1)->SetTmpDefaultItem(arg2);
27933
27934 wxPyEndAllowThreads(__tstate);
27935 if (PyErr_Occurred()) SWIG_fail;
27936 }
27937 Py_INCREF(Py_None); resultobj = Py_None;
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27945 PyObject *resultobj;
27946 wxWindow *arg1 = (wxWindow *) 0 ;
27947 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27948 bool result;
27949 PyObject * obj0 = 0 ;
27950 PyObject * obj1 = 0 ;
27951 char *kwnames[] = {
27952 (char *) "self",(char *) "flags", NULL
27953 };
27954
27955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27957 if (SWIG_arg_fail(1)) SWIG_fail;
27958 if (obj1) {
27959 {
27960 arg2 = (int)(SWIG_As_int(obj1));
27961 if (SWIG_arg_fail(2)) SWIG_fail;
27962 }
27963 }
27964 {
27965 PyThreadState* __tstate = wxPyBeginAllowThreads();
27966 result = (bool)(arg1)->Navigate(arg2);
27967
27968 wxPyEndAllowThreads(__tstate);
27969 if (PyErr_Occurred()) SWIG_fail;
27970 }
27971 {
27972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27973 }
27974 return resultobj;
27975 fail:
27976 return NULL;
27977 }
27978
27979
27980 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27981 PyObject *resultobj;
27982 wxWindow *arg1 = (wxWindow *) 0 ;
27983 wxWindow *arg2 = (wxWindow *) 0 ;
27984 PyObject * obj0 = 0 ;
27985 PyObject * obj1 = 0 ;
27986 char *kwnames[] = {
27987 (char *) "self",(char *) "win", NULL
27988 };
27989
27990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27992 if (SWIG_arg_fail(1)) SWIG_fail;
27993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27994 if (SWIG_arg_fail(2)) SWIG_fail;
27995 {
27996 PyThreadState* __tstate = wxPyBeginAllowThreads();
27997 (arg1)->MoveAfterInTabOrder(arg2);
27998
27999 wxPyEndAllowThreads(__tstate);
28000 if (PyErr_Occurred()) SWIG_fail;
28001 }
28002 Py_INCREF(Py_None); resultobj = Py_None;
28003 return resultobj;
28004 fail:
28005 return NULL;
28006 }
28007
28008
28009 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28010 PyObject *resultobj;
28011 wxWindow *arg1 = (wxWindow *) 0 ;
28012 wxWindow *arg2 = (wxWindow *) 0 ;
28013 PyObject * obj0 = 0 ;
28014 PyObject * obj1 = 0 ;
28015 char *kwnames[] = {
28016 (char *) "self",(char *) "win", NULL
28017 };
28018
28019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28021 if (SWIG_arg_fail(1)) SWIG_fail;
28022 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28023 if (SWIG_arg_fail(2)) SWIG_fail;
28024 {
28025 PyThreadState* __tstate = wxPyBeginAllowThreads();
28026 (arg1)->MoveBeforeInTabOrder(arg2);
28027
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 Py_INCREF(Py_None); resultobj = Py_None;
28032 return resultobj;
28033 fail:
28034 return NULL;
28035 }
28036
28037
28038 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28039 PyObject *resultobj;
28040 wxWindow *arg1 = (wxWindow *) 0 ;
28041 PyObject *result;
28042 PyObject * obj0 = 0 ;
28043 char *kwnames[] = {
28044 (char *) "self", NULL
28045 };
28046
28047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28049 if (SWIG_arg_fail(1)) SWIG_fail;
28050 {
28051 PyThreadState* __tstate = wxPyBeginAllowThreads();
28052 result = (PyObject *)wxWindow_GetChildren(arg1);
28053
28054 wxPyEndAllowThreads(__tstate);
28055 if (PyErr_Occurred()) SWIG_fail;
28056 }
28057 resultobj = result;
28058 return resultobj;
28059 fail:
28060 return NULL;
28061 }
28062
28063
28064 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28065 PyObject *resultobj;
28066 wxWindow *arg1 = (wxWindow *) 0 ;
28067 wxWindow *result;
28068 PyObject * obj0 = 0 ;
28069 char *kwnames[] = {
28070 (char *) "self", NULL
28071 };
28072
28073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28075 if (SWIG_arg_fail(1)) SWIG_fail;
28076 {
28077 PyThreadState* __tstate = wxPyBeginAllowThreads();
28078 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28079
28080 wxPyEndAllowThreads(__tstate);
28081 if (PyErr_Occurred()) SWIG_fail;
28082 }
28083 {
28084 resultobj = wxPyMake_wxObject(result, 0);
28085 }
28086 return resultobj;
28087 fail:
28088 return NULL;
28089 }
28090
28091
28092 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28093 PyObject *resultobj;
28094 wxWindow *arg1 = (wxWindow *) 0 ;
28095 wxWindow *result;
28096 PyObject * obj0 = 0 ;
28097 char *kwnames[] = {
28098 (char *) "self", NULL
28099 };
28100
28101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28103 if (SWIG_arg_fail(1)) SWIG_fail;
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28107
28108 wxPyEndAllowThreads(__tstate);
28109 if (PyErr_Occurred()) SWIG_fail;
28110 }
28111 {
28112 resultobj = wxPyMake_wxObject(result, 0);
28113 }
28114 return resultobj;
28115 fail:
28116 return NULL;
28117 }
28118
28119
28120 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28121 PyObject *resultobj;
28122 wxWindow *arg1 = (wxWindow *) 0 ;
28123 bool result;
28124 PyObject * obj0 = 0 ;
28125 char *kwnames[] = {
28126 (char *) "self", NULL
28127 };
28128
28129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28131 if (SWIG_arg_fail(1)) SWIG_fail;
28132 {
28133 PyThreadState* __tstate = wxPyBeginAllowThreads();
28134 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28135
28136 wxPyEndAllowThreads(__tstate);
28137 if (PyErr_Occurred()) SWIG_fail;
28138 }
28139 {
28140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28141 }
28142 return resultobj;
28143 fail:
28144 return NULL;
28145 }
28146
28147
28148 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28149 PyObject *resultobj;
28150 wxWindow *arg1 = (wxWindow *) 0 ;
28151 wxWindow *arg2 = (wxWindow *) 0 ;
28152 bool result;
28153 PyObject * obj0 = 0 ;
28154 PyObject * obj1 = 0 ;
28155 char *kwnames[] = {
28156 (char *) "self",(char *) "newParent", NULL
28157 };
28158
28159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28161 if (SWIG_arg_fail(1)) SWIG_fail;
28162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28163 if (SWIG_arg_fail(2)) SWIG_fail;
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 result = (bool)(arg1)->Reparent(arg2);
28167
28168 wxPyEndAllowThreads(__tstate);
28169 if (PyErr_Occurred()) SWIG_fail;
28170 }
28171 {
28172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28173 }
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj;
28182 wxWindow *arg1 = (wxWindow *) 0 ;
28183 wxWindow *arg2 = (wxWindow *) 0 ;
28184 PyObject * obj0 = 0 ;
28185 PyObject * obj1 = 0 ;
28186 char *kwnames[] = {
28187 (char *) "self",(char *) "child", NULL
28188 };
28189
28190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28192 if (SWIG_arg_fail(1)) SWIG_fail;
28193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28194 if (SWIG_arg_fail(2)) SWIG_fail;
28195 {
28196 PyThreadState* __tstate = wxPyBeginAllowThreads();
28197 (arg1)->AddChild(arg2);
28198
28199 wxPyEndAllowThreads(__tstate);
28200 if (PyErr_Occurred()) SWIG_fail;
28201 }
28202 Py_INCREF(Py_None); resultobj = Py_None;
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28210 PyObject *resultobj;
28211 wxWindow *arg1 = (wxWindow *) 0 ;
28212 wxWindow *arg2 = (wxWindow *) 0 ;
28213 PyObject * obj0 = 0 ;
28214 PyObject * obj1 = 0 ;
28215 char *kwnames[] = {
28216 (char *) "self",(char *) "child", NULL
28217 };
28218
28219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28221 if (SWIG_arg_fail(1)) SWIG_fail;
28222 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28223 if (SWIG_arg_fail(2)) SWIG_fail;
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 (arg1)->RemoveChild(arg2);
28227
28228 wxPyEndAllowThreads(__tstate);
28229 if (PyErr_Occurred()) SWIG_fail;
28230 }
28231 Py_INCREF(Py_None); resultobj = Py_None;
28232 return resultobj;
28233 fail:
28234 return NULL;
28235 }
28236
28237
28238 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28239 PyObject *resultobj;
28240 wxWindow *arg1 = (wxWindow *) 0 ;
28241 long arg2 ;
28242 wxWindow *result;
28243 PyObject * obj0 = 0 ;
28244 PyObject * obj1 = 0 ;
28245 char *kwnames[] = {
28246 (char *) "self",(char *) "winid", NULL
28247 };
28248
28249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28251 if (SWIG_arg_fail(1)) SWIG_fail;
28252 {
28253 arg2 = (long)(SWIG_As_long(obj1));
28254 if (SWIG_arg_fail(2)) SWIG_fail;
28255 }
28256 {
28257 PyThreadState* __tstate = wxPyBeginAllowThreads();
28258 result = (wxWindow *)(arg1)->FindWindow(arg2);
28259
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 {
28264 resultobj = wxPyMake_wxObject(result, 0);
28265 }
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28273 PyObject *resultobj;
28274 wxWindow *arg1 = (wxWindow *) 0 ;
28275 wxString *arg2 = 0 ;
28276 wxWindow *result;
28277 bool temp2 = false ;
28278 PyObject * obj0 = 0 ;
28279 PyObject * obj1 = 0 ;
28280 char *kwnames[] = {
28281 (char *) "self",(char *) "name", NULL
28282 };
28283
28284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28286 if (SWIG_arg_fail(1)) SWIG_fail;
28287 {
28288 arg2 = wxString_in_helper(obj1);
28289 if (arg2 == NULL) SWIG_fail;
28290 temp2 = true;
28291 }
28292 {
28293 PyThreadState* __tstate = wxPyBeginAllowThreads();
28294 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28295
28296 wxPyEndAllowThreads(__tstate);
28297 if (PyErr_Occurred()) SWIG_fail;
28298 }
28299 {
28300 resultobj = wxPyMake_wxObject(result, 0);
28301 }
28302 {
28303 if (temp2)
28304 delete arg2;
28305 }
28306 return resultobj;
28307 fail:
28308 {
28309 if (temp2)
28310 delete arg2;
28311 }
28312 return NULL;
28313 }
28314
28315
28316 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28317 PyObject *resultobj;
28318 wxWindow *arg1 = (wxWindow *) 0 ;
28319 wxEvtHandler *result;
28320 PyObject * obj0 = 0 ;
28321 char *kwnames[] = {
28322 (char *) "self", NULL
28323 };
28324
28325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28327 if (SWIG_arg_fail(1)) SWIG_fail;
28328 {
28329 PyThreadState* __tstate = wxPyBeginAllowThreads();
28330 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28331
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 {
28336 resultobj = wxPyMake_wxObject(result, 0);
28337 }
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28345 PyObject *resultobj;
28346 wxWindow *arg1 = (wxWindow *) 0 ;
28347 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28348 PyObject * obj0 = 0 ;
28349 PyObject * obj1 = 0 ;
28350 char *kwnames[] = {
28351 (char *) "self",(char *) "handler", NULL
28352 };
28353
28354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28356 if (SWIG_arg_fail(1)) SWIG_fail;
28357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28358 if (SWIG_arg_fail(2)) SWIG_fail;
28359 {
28360 PyThreadState* __tstate = wxPyBeginAllowThreads();
28361 (arg1)->SetEventHandler(arg2);
28362
28363 wxPyEndAllowThreads(__tstate);
28364 if (PyErr_Occurred()) SWIG_fail;
28365 }
28366 Py_INCREF(Py_None); resultobj = Py_None;
28367 return resultobj;
28368 fail:
28369 return NULL;
28370 }
28371
28372
28373 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28374 PyObject *resultobj;
28375 wxWindow *arg1 = (wxWindow *) 0 ;
28376 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28377 PyObject * obj0 = 0 ;
28378 PyObject * obj1 = 0 ;
28379 char *kwnames[] = {
28380 (char *) "self",(char *) "handler", NULL
28381 };
28382
28383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28385 if (SWIG_arg_fail(1)) SWIG_fail;
28386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28387 if (SWIG_arg_fail(2)) SWIG_fail;
28388 {
28389 PyThreadState* __tstate = wxPyBeginAllowThreads();
28390 (arg1)->PushEventHandler(arg2);
28391
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 Py_INCREF(Py_None); resultobj = Py_None;
28396 return resultobj;
28397 fail:
28398 return NULL;
28399 }
28400
28401
28402 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28403 PyObject *resultobj;
28404 wxWindow *arg1 = (wxWindow *) 0 ;
28405 bool arg2 = (bool) false ;
28406 wxEvtHandler *result;
28407 PyObject * obj0 = 0 ;
28408 PyObject * obj1 = 0 ;
28409 char *kwnames[] = {
28410 (char *) "self",(char *) "deleteHandler", NULL
28411 };
28412
28413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28415 if (SWIG_arg_fail(1)) SWIG_fail;
28416 if (obj1) {
28417 {
28418 arg2 = (bool)(SWIG_As_bool(obj1));
28419 if (SWIG_arg_fail(2)) SWIG_fail;
28420 }
28421 }
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28425
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 {
28430 resultobj = wxPyMake_wxObject(result, 0);
28431 }
28432 return resultobj;
28433 fail:
28434 return NULL;
28435 }
28436
28437
28438 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28439 PyObject *resultobj;
28440 wxWindow *arg1 = (wxWindow *) 0 ;
28441 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28442 bool result;
28443 PyObject * obj0 = 0 ;
28444 PyObject * obj1 = 0 ;
28445 char *kwnames[] = {
28446 (char *) "self",(char *) "handler", NULL
28447 };
28448
28449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28451 if (SWIG_arg_fail(1)) SWIG_fail;
28452 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28453 if (SWIG_arg_fail(2)) SWIG_fail;
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 result = (bool)(arg1)->RemoveEventHandler(arg2);
28457
28458 wxPyEndAllowThreads(__tstate);
28459 if (PyErr_Occurred()) SWIG_fail;
28460 }
28461 {
28462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28463 }
28464 return resultobj;
28465 fail:
28466 return NULL;
28467 }
28468
28469
28470 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28471 PyObject *resultobj;
28472 wxWindow *arg1 = (wxWindow *) 0 ;
28473 wxValidator *arg2 = 0 ;
28474 PyObject * obj0 = 0 ;
28475 PyObject * obj1 = 0 ;
28476 char *kwnames[] = {
28477 (char *) "self",(char *) "validator", NULL
28478 };
28479
28480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28482 if (SWIG_arg_fail(1)) SWIG_fail;
28483 {
28484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28485 if (SWIG_arg_fail(2)) SWIG_fail;
28486 if (arg2 == NULL) {
28487 SWIG_null_ref("wxValidator");
28488 }
28489 if (SWIG_arg_fail(2)) SWIG_fail;
28490 }
28491 {
28492 PyThreadState* __tstate = wxPyBeginAllowThreads();
28493 (arg1)->SetValidator((wxValidator const &)*arg2);
28494
28495 wxPyEndAllowThreads(__tstate);
28496 if (PyErr_Occurred()) SWIG_fail;
28497 }
28498 Py_INCREF(Py_None); resultobj = Py_None;
28499 return resultobj;
28500 fail:
28501 return NULL;
28502 }
28503
28504
28505 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28506 PyObject *resultobj;
28507 wxWindow *arg1 = (wxWindow *) 0 ;
28508 wxValidator *result;
28509 PyObject * obj0 = 0 ;
28510 char *kwnames[] = {
28511 (char *) "self", NULL
28512 };
28513
28514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28516 if (SWIG_arg_fail(1)) SWIG_fail;
28517 {
28518 PyThreadState* __tstate = wxPyBeginAllowThreads();
28519 result = (wxValidator *)(arg1)->GetValidator();
28520
28521 wxPyEndAllowThreads(__tstate);
28522 if (PyErr_Occurred()) SWIG_fail;
28523 }
28524 {
28525 resultobj = wxPyMake_wxObject(result, 0);
28526 }
28527 return resultobj;
28528 fail:
28529 return NULL;
28530 }
28531
28532
28533 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28534 PyObject *resultobj;
28535 wxWindow *arg1 = (wxWindow *) 0 ;
28536 bool result;
28537 PyObject * obj0 = 0 ;
28538 char *kwnames[] = {
28539 (char *) "self", NULL
28540 };
28541
28542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28544 if (SWIG_arg_fail(1)) SWIG_fail;
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 result = (bool)(arg1)->Validate();
28548
28549 wxPyEndAllowThreads(__tstate);
28550 if (PyErr_Occurred()) SWIG_fail;
28551 }
28552 {
28553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28554 }
28555 return resultobj;
28556 fail:
28557 return NULL;
28558 }
28559
28560
28561 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28562 PyObject *resultobj;
28563 wxWindow *arg1 = (wxWindow *) 0 ;
28564 bool result;
28565 PyObject * obj0 = 0 ;
28566 char *kwnames[] = {
28567 (char *) "self", NULL
28568 };
28569
28570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28572 if (SWIG_arg_fail(1)) SWIG_fail;
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 result = (bool)(arg1)->TransferDataToWindow();
28576
28577 wxPyEndAllowThreads(__tstate);
28578 if (PyErr_Occurred()) SWIG_fail;
28579 }
28580 {
28581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28582 }
28583 return resultobj;
28584 fail:
28585 return NULL;
28586 }
28587
28588
28589 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28590 PyObject *resultobj;
28591 wxWindow *arg1 = (wxWindow *) 0 ;
28592 bool result;
28593 PyObject * obj0 = 0 ;
28594 char *kwnames[] = {
28595 (char *) "self", NULL
28596 };
28597
28598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28600 if (SWIG_arg_fail(1)) SWIG_fail;
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 result = (bool)(arg1)->TransferDataFromWindow();
28604
28605 wxPyEndAllowThreads(__tstate);
28606 if (PyErr_Occurred()) SWIG_fail;
28607 }
28608 {
28609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28610 }
28611 return resultobj;
28612 fail:
28613 return NULL;
28614 }
28615
28616
28617 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28618 PyObject *resultobj;
28619 wxWindow *arg1 = (wxWindow *) 0 ;
28620 PyObject * obj0 = 0 ;
28621 char *kwnames[] = {
28622 (char *) "self", NULL
28623 };
28624
28625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28627 if (SWIG_arg_fail(1)) SWIG_fail;
28628 {
28629 PyThreadState* __tstate = wxPyBeginAllowThreads();
28630 (arg1)->InitDialog();
28631
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 Py_INCREF(Py_None); resultobj = Py_None;
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28643 PyObject *resultobj;
28644 wxWindow *arg1 = (wxWindow *) 0 ;
28645 wxAcceleratorTable *arg2 = 0 ;
28646 PyObject * obj0 = 0 ;
28647 PyObject * obj1 = 0 ;
28648 char *kwnames[] = {
28649 (char *) "self",(char *) "accel", NULL
28650 };
28651
28652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28654 if (SWIG_arg_fail(1)) SWIG_fail;
28655 {
28656 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28657 if (SWIG_arg_fail(2)) SWIG_fail;
28658 if (arg2 == NULL) {
28659 SWIG_null_ref("wxAcceleratorTable");
28660 }
28661 if (SWIG_arg_fail(2)) SWIG_fail;
28662 }
28663 {
28664 PyThreadState* __tstate = wxPyBeginAllowThreads();
28665 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28666
28667 wxPyEndAllowThreads(__tstate);
28668 if (PyErr_Occurred()) SWIG_fail;
28669 }
28670 Py_INCREF(Py_None); resultobj = Py_None;
28671 return resultobj;
28672 fail:
28673 return NULL;
28674 }
28675
28676
28677 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28678 PyObject *resultobj;
28679 wxWindow *arg1 = (wxWindow *) 0 ;
28680 wxAcceleratorTable *result;
28681 PyObject * obj0 = 0 ;
28682 char *kwnames[] = {
28683 (char *) "self", NULL
28684 };
28685
28686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28688 if (SWIG_arg_fail(1)) SWIG_fail;
28689 {
28690 PyThreadState* __tstate = wxPyBeginAllowThreads();
28691 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28692
28693 wxPyEndAllowThreads(__tstate);
28694 if (PyErr_Occurred()) SWIG_fail;
28695 }
28696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj;
28705 wxWindow *arg1 = (wxWindow *) 0 ;
28706 int arg2 ;
28707 int arg3 ;
28708 int arg4 ;
28709 bool result;
28710 PyObject * obj0 = 0 ;
28711 PyObject * obj1 = 0 ;
28712 PyObject * obj2 = 0 ;
28713 PyObject * obj3 = 0 ;
28714 char *kwnames[] = {
28715 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28716 };
28717
28718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28720 if (SWIG_arg_fail(1)) SWIG_fail;
28721 {
28722 arg2 = (int)(SWIG_As_int(obj1));
28723 if (SWIG_arg_fail(2)) SWIG_fail;
28724 }
28725 {
28726 arg3 = (int)(SWIG_As_int(obj2));
28727 if (SWIG_arg_fail(3)) SWIG_fail;
28728 }
28729 {
28730 arg4 = (int)(SWIG_As_int(obj3));
28731 if (SWIG_arg_fail(4)) SWIG_fail;
28732 }
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28736
28737 wxPyEndAllowThreads(__tstate);
28738 if (PyErr_Occurred()) SWIG_fail;
28739 }
28740 {
28741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28742 }
28743 return resultobj;
28744 fail:
28745 return NULL;
28746 }
28747
28748
28749 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28750 PyObject *resultobj;
28751 wxWindow *arg1 = (wxWindow *) 0 ;
28752 int arg2 ;
28753 bool result;
28754 PyObject * obj0 = 0 ;
28755 PyObject * obj1 = 0 ;
28756 char *kwnames[] = {
28757 (char *) "self",(char *) "hotkeyId", NULL
28758 };
28759
28760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28762 if (SWIG_arg_fail(1)) SWIG_fail;
28763 {
28764 arg2 = (int)(SWIG_As_int(obj1));
28765 if (SWIG_arg_fail(2)) SWIG_fail;
28766 }
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28770
28771 wxPyEndAllowThreads(__tstate);
28772 if (PyErr_Occurred()) SWIG_fail;
28773 }
28774 {
28775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28776 }
28777 return resultobj;
28778 fail:
28779 return NULL;
28780 }
28781
28782
28783 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28784 PyObject *resultobj;
28785 wxWindow *arg1 = (wxWindow *) 0 ;
28786 wxPoint *arg2 = 0 ;
28787 wxPoint result;
28788 wxPoint temp2 ;
28789 PyObject * obj0 = 0 ;
28790 PyObject * obj1 = 0 ;
28791 char *kwnames[] = {
28792 (char *) "self",(char *) "pt", NULL
28793 };
28794
28795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28797 if (SWIG_arg_fail(1)) SWIG_fail;
28798 {
28799 arg2 = &temp2;
28800 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28801 }
28802 {
28803 PyThreadState* __tstate = wxPyBeginAllowThreads();
28804 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28805
28806 wxPyEndAllowThreads(__tstate);
28807 if (PyErr_Occurred()) SWIG_fail;
28808 }
28809 {
28810 wxPoint * resultptr;
28811 resultptr = new wxPoint((wxPoint &)(result));
28812 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28813 }
28814 return resultobj;
28815 fail:
28816 return NULL;
28817 }
28818
28819
28820 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28821 PyObject *resultobj;
28822 wxWindow *arg1 = (wxWindow *) 0 ;
28823 wxSize *arg2 = 0 ;
28824 wxSize result;
28825 wxSize temp2 ;
28826 PyObject * obj0 = 0 ;
28827 PyObject * obj1 = 0 ;
28828 char *kwnames[] = {
28829 (char *) "self",(char *) "sz", NULL
28830 };
28831
28832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28834 if (SWIG_arg_fail(1)) SWIG_fail;
28835 {
28836 arg2 = &temp2;
28837 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28838 }
28839 {
28840 PyThreadState* __tstate = wxPyBeginAllowThreads();
28841 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28842
28843 wxPyEndAllowThreads(__tstate);
28844 if (PyErr_Occurred()) SWIG_fail;
28845 }
28846 {
28847 wxSize * resultptr;
28848 resultptr = new wxSize((wxSize &)(result));
28849 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28850 }
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj;
28859 wxWindow *arg1 = (wxWindow *) 0 ;
28860 wxPoint *arg2 = 0 ;
28861 wxPoint result;
28862 wxPoint temp2 ;
28863 PyObject * obj0 = 0 ;
28864 PyObject * obj1 = 0 ;
28865 char *kwnames[] = {
28866 (char *) "self",(char *) "pt", NULL
28867 };
28868
28869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28871 if (SWIG_arg_fail(1)) SWIG_fail;
28872 {
28873 arg2 = &temp2;
28874 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28875 }
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28879
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 {
28884 wxPoint * resultptr;
28885 resultptr = new wxPoint((wxPoint &)(result));
28886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28887 }
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28895 PyObject *resultobj;
28896 wxWindow *arg1 = (wxWindow *) 0 ;
28897 wxSize *arg2 = 0 ;
28898 wxSize result;
28899 wxSize temp2 ;
28900 PyObject * obj0 = 0 ;
28901 PyObject * obj1 = 0 ;
28902 char *kwnames[] = {
28903 (char *) "self",(char *) "sz", NULL
28904 };
28905
28906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28908 if (SWIG_arg_fail(1)) SWIG_fail;
28909 {
28910 arg2 = &temp2;
28911 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28912 }
28913 {
28914 PyThreadState* __tstate = wxPyBeginAllowThreads();
28915 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28916
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 {
28921 wxSize * resultptr;
28922 resultptr = new wxSize((wxSize &)(result));
28923 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28924 }
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj;
28933 wxWindow *arg1 = (wxWindow *) 0 ;
28934 wxPoint *arg2 = 0 ;
28935 wxPoint result;
28936 wxPoint temp2 ;
28937 PyObject * obj0 = 0 ;
28938 PyObject * obj1 = 0 ;
28939 char *kwnames[] = {
28940 (char *) "self",(char *) "pt", NULL
28941 };
28942
28943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28945 if (SWIG_arg_fail(1)) SWIG_fail;
28946 {
28947 arg2 = &temp2;
28948 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28949 }
28950 {
28951 PyThreadState* __tstate = wxPyBeginAllowThreads();
28952 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28953
28954 wxPyEndAllowThreads(__tstate);
28955 if (PyErr_Occurred()) SWIG_fail;
28956 }
28957 {
28958 wxPoint * resultptr;
28959 resultptr = new wxPoint((wxPoint &)(result));
28960 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28961 }
28962 return resultobj;
28963 fail:
28964 return NULL;
28965 }
28966
28967
28968 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28969 PyObject *resultobj;
28970 wxWindow *arg1 = (wxWindow *) 0 ;
28971 wxSize *arg2 = 0 ;
28972 wxSize result;
28973 wxSize temp2 ;
28974 PyObject * obj0 = 0 ;
28975 PyObject * obj1 = 0 ;
28976 char *kwnames[] = {
28977 (char *) "self",(char *) "sz", NULL
28978 };
28979
28980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28982 if (SWIG_arg_fail(1)) SWIG_fail;
28983 {
28984 arg2 = &temp2;
28985 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28986 }
28987 {
28988 PyThreadState* __tstate = wxPyBeginAllowThreads();
28989 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28990
28991 wxPyEndAllowThreads(__tstate);
28992 if (PyErr_Occurred()) SWIG_fail;
28993 }
28994 {
28995 wxSize * resultptr;
28996 resultptr = new wxSize((wxSize &)(result));
28997 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28998 }
28999 return resultobj;
29000 fail:
29001 return NULL;
29002 }
29003
29004
29005 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29006 PyObject *resultobj;
29007 wxWindow *arg1 = (wxWindow *) 0 ;
29008 int arg2 ;
29009 int arg3 ;
29010 PyObject * obj0 = 0 ;
29011 PyObject * obj1 = 0 ;
29012 PyObject * obj2 = 0 ;
29013 char *kwnames[] = {
29014 (char *) "self",(char *) "x",(char *) "y", NULL
29015 };
29016
29017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29019 if (SWIG_arg_fail(1)) SWIG_fail;
29020 {
29021 arg2 = (int)(SWIG_As_int(obj1));
29022 if (SWIG_arg_fail(2)) SWIG_fail;
29023 }
29024 {
29025 arg3 = (int)(SWIG_As_int(obj2));
29026 if (SWIG_arg_fail(3)) SWIG_fail;
29027 }
29028 {
29029 PyThreadState* __tstate = wxPyBeginAllowThreads();
29030 (arg1)->WarpPointer(arg2,arg3);
29031
29032 wxPyEndAllowThreads(__tstate);
29033 if (PyErr_Occurred()) SWIG_fail;
29034 }
29035 Py_INCREF(Py_None); resultobj = Py_None;
29036 return resultobj;
29037 fail:
29038 return NULL;
29039 }
29040
29041
29042 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29043 PyObject *resultobj;
29044 wxWindow *arg1 = (wxWindow *) 0 ;
29045 PyObject * obj0 = 0 ;
29046 char *kwnames[] = {
29047 (char *) "self", NULL
29048 };
29049
29050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29052 if (SWIG_arg_fail(1)) SWIG_fail;
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 (arg1)->CaptureMouse();
29056
29057 wxPyEndAllowThreads(__tstate);
29058 if (PyErr_Occurred()) SWIG_fail;
29059 }
29060 Py_INCREF(Py_None); resultobj = Py_None;
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29068 PyObject *resultobj;
29069 wxWindow *arg1 = (wxWindow *) 0 ;
29070 PyObject * obj0 = 0 ;
29071 char *kwnames[] = {
29072 (char *) "self", NULL
29073 };
29074
29075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29077 if (SWIG_arg_fail(1)) SWIG_fail;
29078 {
29079 PyThreadState* __tstate = wxPyBeginAllowThreads();
29080 (arg1)->ReleaseMouse();
29081
29082 wxPyEndAllowThreads(__tstate);
29083 if (PyErr_Occurred()) SWIG_fail;
29084 }
29085 Py_INCREF(Py_None); resultobj = Py_None;
29086 return resultobj;
29087 fail:
29088 return NULL;
29089 }
29090
29091
29092 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29093 PyObject *resultobj;
29094 wxWindow *result;
29095 char *kwnames[] = {
29096 NULL
29097 };
29098
29099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29100 {
29101 if (!wxPyCheckForApp()) SWIG_fail;
29102 PyThreadState* __tstate = wxPyBeginAllowThreads();
29103 result = (wxWindow *)wxWindow::GetCapture();
29104
29105 wxPyEndAllowThreads(__tstate);
29106 if (PyErr_Occurred()) SWIG_fail;
29107 }
29108 {
29109 resultobj = wxPyMake_wxObject(result, 0);
29110 }
29111 return resultobj;
29112 fail:
29113 return NULL;
29114 }
29115
29116
29117 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29118 PyObject *resultobj;
29119 wxWindow *arg1 = (wxWindow *) 0 ;
29120 bool result;
29121 PyObject * obj0 = 0 ;
29122 char *kwnames[] = {
29123 (char *) "self", NULL
29124 };
29125
29126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29128 if (SWIG_arg_fail(1)) SWIG_fail;
29129 {
29130 PyThreadState* __tstate = wxPyBeginAllowThreads();
29131 result = (bool)((wxWindow const *)arg1)->HasCapture();
29132
29133 wxPyEndAllowThreads(__tstate);
29134 if (PyErr_Occurred()) SWIG_fail;
29135 }
29136 {
29137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29138 }
29139 return resultobj;
29140 fail:
29141 return NULL;
29142 }
29143
29144
29145 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29146 PyObject *resultobj;
29147 wxWindow *arg1 = (wxWindow *) 0 ;
29148 bool arg2 = (bool) true ;
29149 wxRect *arg3 = (wxRect *) NULL ;
29150 PyObject * obj0 = 0 ;
29151 PyObject * obj1 = 0 ;
29152 PyObject * obj2 = 0 ;
29153 char *kwnames[] = {
29154 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29155 };
29156
29157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29159 if (SWIG_arg_fail(1)) SWIG_fail;
29160 if (obj1) {
29161 {
29162 arg2 = (bool)(SWIG_As_bool(obj1));
29163 if (SWIG_arg_fail(2)) SWIG_fail;
29164 }
29165 }
29166 if (obj2) {
29167 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29168 if (SWIG_arg_fail(3)) SWIG_fail;
29169 }
29170 {
29171 PyThreadState* __tstate = wxPyBeginAllowThreads();
29172 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29173
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 Py_INCREF(Py_None); resultobj = Py_None;
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29185 PyObject *resultobj;
29186 wxWindow *arg1 = (wxWindow *) 0 ;
29187 wxRect *arg2 = 0 ;
29188 bool arg3 = (bool) true ;
29189 wxRect temp2 ;
29190 PyObject * obj0 = 0 ;
29191 PyObject * obj1 = 0 ;
29192 PyObject * obj2 = 0 ;
29193 char *kwnames[] = {
29194 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29195 };
29196
29197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29199 if (SWIG_arg_fail(1)) SWIG_fail;
29200 {
29201 arg2 = &temp2;
29202 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29203 }
29204 if (obj2) {
29205 {
29206 arg3 = (bool)(SWIG_As_bool(obj2));
29207 if (SWIG_arg_fail(3)) SWIG_fail;
29208 }
29209 }
29210 {
29211 PyThreadState* __tstate = wxPyBeginAllowThreads();
29212 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29213
29214 wxPyEndAllowThreads(__tstate);
29215 if (PyErr_Occurred()) SWIG_fail;
29216 }
29217 Py_INCREF(Py_None); resultobj = Py_None;
29218 return resultobj;
29219 fail:
29220 return NULL;
29221 }
29222
29223
29224 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29225 PyObject *resultobj;
29226 wxWindow *arg1 = (wxWindow *) 0 ;
29227 PyObject * obj0 = 0 ;
29228 char *kwnames[] = {
29229 (char *) "self", NULL
29230 };
29231
29232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29234 if (SWIG_arg_fail(1)) SWIG_fail;
29235 {
29236 PyThreadState* __tstate = wxPyBeginAllowThreads();
29237 (arg1)->Update();
29238
29239 wxPyEndAllowThreads(__tstate);
29240 if (PyErr_Occurred()) SWIG_fail;
29241 }
29242 Py_INCREF(Py_None); resultobj = Py_None;
29243 return resultobj;
29244 fail:
29245 return NULL;
29246 }
29247
29248
29249 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29250 PyObject *resultobj;
29251 wxWindow *arg1 = (wxWindow *) 0 ;
29252 PyObject * obj0 = 0 ;
29253 char *kwnames[] = {
29254 (char *) "self", NULL
29255 };
29256
29257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29259 if (SWIG_arg_fail(1)) SWIG_fail;
29260 {
29261 PyThreadState* __tstate = wxPyBeginAllowThreads();
29262 (arg1)->ClearBackground();
29263
29264 wxPyEndAllowThreads(__tstate);
29265 if (PyErr_Occurred()) SWIG_fail;
29266 }
29267 Py_INCREF(Py_None); resultobj = Py_None;
29268 return resultobj;
29269 fail:
29270 return NULL;
29271 }
29272
29273
29274 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29275 PyObject *resultobj;
29276 wxWindow *arg1 = (wxWindow *) 0 ;
29277 PyObject * obj0 = 0 ;
29278 char *kwnames[] = {
29279 (char *) "self", NULL
29280 };
29281
29282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29284 if (SWIG_arg_fail(1)) SWIG_fail;
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 (arg1)->Freeze();
29288
29289 wxPyEndAllowThreads(__tstate);
29290 if (PyErr_Occurred()) SWIG_fail;
29291 }
29292 Py_INCREF(Py_None); resultobj = Py_None;
29293 return resultobj;
29294 fail:
29295 return NULL;
29296 }
29297
29298
29299 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29300 PyObject *resultobj;
29301 wxWindow *arg1 = (wxWindow *) 0 ;
29302 PyObject * obj0 = 0 ;
29303 char *kwnames[] = {
29304 (char *) "self", NULL
29305 };
29306
29307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29309 if (SWIG_arg_fail(1)) SWIG_fail;
29310 {
29311 PyThreadState* __tstate = wxPyBeginAllowThreads();
29312 (arg1)->Thaw();
29313
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 Py_INCREF(Py_None); resultobj = Py_None;
29318 return resultobj;
29319 fail:
29320 return NULL;
29321 }
29322
29323
29324 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29325 PyObject *resultobj;
29326 wxWindow *arg1 = (wxWindow *) 0 ;
29327 wxDC *arg2 = 0 ;
29328 PyObject * obj0 = 0 ;
29329 PyObject * obj1 = 0 ;
29330 char *kwnames[] = {
29331 (char *) "self",(char *) "dc", NULL
29332 };
29333
29334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29336 if (SWIG_arg_fail(1)) SWIG_fail;
29337 {
29338 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29339 if (SWIG_arg_fail(2)) SWIG_fail;
29340 if (arg2 == NULL) {
29341 SWIG_null_ref("wxDC");
29342 }
29343 if (SWIG_arg_fail(2)) SWIG_fail;
29344 }
29345 {
29346 PyThreadState* __tstate = wxPyBeginAllowThreads();
29347 (arg1)->PrepareDC(*arg2);
29348
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 Py_INCREF(Py_None); resultobj = Py_None;
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29360 PyObject *resultobj;
29361 wxWindow *arg1 = (wxWindow *) 0 ;
29362 wxRegion *result;
29363 PyObject * obj0 = 0 ;
29364 char *kwnames[] = {
29365 (char *) "self", NULL
29366 };
29367
29368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29370 if (SWIG_arg_fail(1)) SWIG_fail;
29371 {
29372 PyThreadState* __tstate = wxPyBeginAllowThreads();
29373 {
29374 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29375 result = (wxRegion *) &_result_ref;
29376 }
29377
29378 wxPyEndAllowThreads(__tstate);
29379 if (PyErr_Occurred()) SWIG_fail;
29380 }
29381 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29382 return resultobj;
29383 fail:
29384 return NULL;
29385 }
29386
29387
29388 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29389 PyObject *resultobj;
29390 wxWindow *arg1 = (wxWindow *) 0 ;
29391 wxRect result;
29392 PyObject * obj0 = 0 ;
29393 char *kwnames[] = {
29394 (char *) "self", NULL
29395 };
29396
29397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29399 if (SWIG_arg_fail(1)) SWIG_fail;
29400 {
29401 PyThreadState* __tstate = wxPyBeginAllowThreads();
29402 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29403
29404 wxPyEndAllowThreads(__tstate);
29405 if (PyErr_Occurred()) SWIG_fail;
29406 }
29407 {
29408 wxRect * resultptr;
29409 resultptr = new wxRect((wxRect &)(result));
29410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29411 }
29412 return resultobj;
29413 fail:
29414 return NULL;
29415 }
29416
29417
29418 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29419 PyObject *resultobj;
29420 wxWindow *arg1 = (wxWindow *) 0 ;
29421 int arg2 ;
29422 int arg3 ;
29423 int arg4 = (int) 1 ;
29424 int arg5 = (int) 1 ;
29425 bool result;
29426 PyObject * obj0 = 0 ;
29427 PyObject * obj1 = 0 ;
29428 PyObject * obj2 = 0 ;
29429 PyObject * obj3 = 0 ;
29430 PyObject * obj4 = 0 ;
29431 char *kwnames[] = {
29432 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29433 };
29434
29435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29437 if (SWIG_arg_fail(1)) SWIG_fail;
29438 {
29439 arg2 = (int)(SWIG_As_int(obj1));
29440 if (SWIG_arg_fail(2)) SWIG_fail;
29441 }
29442 {
29443 arg3 = (int)(SWIG_As_int(obj2));
29444 if (SWIG_arg_fail(3)) SWIG_fail;
29445 }
29446 if (obj3) {
29447 {
29448 arg4 = (int)(SWIG_As_int(obj3));
29449 if (SWIG_arg_fail(4)) SWIG_fail;
29450 }
29451 }
29452 if (obj4) {
29453 {
29454 arg5 = (int)(SWIG_As_int(obj4));
29455 if (SWIG_arg_fail(5)) SWIG_fail;
29456 }
29457 }
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29461
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 {
29466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29467 }
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj;
29476 wxWindow *arg1 = (wxWindow *) 0 ;
29477 wxPoint *arg2 = 0 ;
29478 bool result;
29479 wxPoint temp2 ;
29480 PyObject * obj0 = 0 ;
29481 PyObject * obj1 = 0 ;
29482 char *kwnames[] = {
29483 (char *) "self",(char *) "pt", NULL
29484 };
29485
29486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29488 if (SWIG_arg_fail(1)) SWIG_fail;
29489 {
29490 arg2 = &temp2;
29491 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29492 }
29493 {
29494 PyThreadState* __tstate = wxPyBeginAllowThreads();
29495 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29496
29497 wxPyEndAllowThreads(__tstate);
29498 if (PyErr_Occurred()) SWIG_fail;
29499 }
29500 {
29501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29502 }
29503 return resultobj;
29504 fail:
29505 return NULL;
29506 }
29507
29508
29509 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29510 PyObject *resultobj;
29511 wxWindow *arg1 = (wxWindow *) 0 ;
29512 wxRect *arg2 = 0 ;
29513 bool result;
29514 wxRect temp2 ;
29515 PyObject * obj0 = 0 ;
29516 PyObject * obj1 = 0 ;
29517 char *kwnames[] = {
29518 (char *) "self",(char *) "rect", NULL
29519 };
29520
29521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29523 if (SWIG_arg_fail(1)) SWIG_fail;
29524 {
29525 arg2 = &temp2;
29526 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29527 }
29528 {
29529 PyThreadState* __tstate = wxPyBeginAllowThreads();
29530 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29531
29532 wxPyEndAllowThreads(__tstate);
29533 if (PyErr_Occurred()) SWIG_fail;
29534 }
29535 {
29536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29537 }
29538 return resultobj;
29539 fail:
29540 return NULL;
29541 }
29542
29543
29544 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29545 PyObject *resultobj;
29546 wxWindow *arg1 = (wxWindow *) 0 ;
29547 wxVisualAttributes result;
29548 PyObject * obj0 = 0 ;
29549 char *kwnames[] = {
29550 (char *) "self", NULL
29551 };
29552
29553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29555 if (SWIG_arg_fail(1)) SWIG_fail;
29556 {
29557 PyThreadState* __tstate = wxPyBeginAllowThreads();
29558 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29559
29560 wxPyEndAllowThreads(__tstate);
29561 if (PyErr_Occurred()) SWIG_fail;
29562 }
29563 {
29564 wxVisualAttributes * resultptr;
29565 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29566 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29567 }
29568 return resultobj;
29569 fail:
29570 return NULL;
29571 }
29572
29573
29574 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29575 PyObject *resultobj;
29576 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29577 wxVisualAttributes result;
29578 PyObject * obj0 = 0 ;
29579 char *kwnames[] = {
29580 (char *) "variant", NULL
29581 };
29582
29583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29584 if (obj0) {
29585 {
29586 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29587 if (SWIG_arg_fail(1)) SWIG_fail;
29588 }
29589 }
29590 {
29591 if (!wxPyCheckForApp()) SWIG_fail;
29592 PyThreadState* __tstate = wxPyBeginAllowThreads();
29593 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29594
29595 wxPyEndAllowThreads(__tstate);
29596 if (PyErr_Occurred()) SWIG_fail;
29597 }
29598 {
29599 wxVisualAttributes * resultptr;
29600 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29602 }
29603 return resultobj;
29604 fail:
29605 return NULL;
29606 }
29607
29608
29609 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29610 PyObject *resultobj;
29611 wxWindow *arg1 = (wxWindow *) 0 ;
29612 wxColour *arg2 = 0 ;
29613 bool result;
29614 wxColour temp2 ;
29615 PyObject * obj0 = 0 ;
29616 PyObject * obj1 = 0 ;
29617 char *kwnames[] = {
29618 (char *) "self",(char *) "colour", NULL
29619 };
29620
29621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29623 if (SWIG_arg_fail(1)) SWIG_fail;
29624 {
29625 arg2 = &temp2;
29626 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29627 }
29628 {
29629 PyThreadState* __tstate = wxPyBeginAllowThreads();
29630 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29631
29632 wxPyEndAllowThreads(__tstate);
29633 if (PyErr_Occurred()) SWIG_fail;
29634 }
29635 {
29636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29637 }
29638 return resultobj;
29639 fail:
29640 return NULL;
29641 }
29642
29643
29644 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29645 PyObject *resultobj;
29646 wxWindow *arg1 = (wxWindow *) 0 ;
29647 wxColour *arg2 = 0 ;
29648 wxColour temp2 ;
29649 PyObject * obj0 = 0 ;
29650 PyObject * obj1 = 0 ;
29651 char *kwnames[] = {
29652 (char *) "self",(char *) "colour", NULL
29653 };
29654
29655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29657 if (SWIG_arg_fail(1)) SWIG_fail;
29658 {
29659 arg2 = &temp2;
29660 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29661 }
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29665
29666 wxPyEndAllowThreads(__tstate);
29667 if (PyErr_Occurred()) SWIG_fail;
29668 }
29669 Py_INCREF(Py_None); resultobj = Py_None;
29670 return resultobj;
29671 fail:
29672 return NULL;
29673 }
29674
29675
29676 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29677 PyObject *resultobj;
29678 wxWindow *arg1 = (wxWindow *) 0 ;
29679 wxColour *arg2 = 0 ;
29680 bool result;
29681 wxColour temp2 ;
29682 PyObject * obj0 = 0 ;
29683 PyObject * obj1 = 0 ;
29684 char *kwnames[] = {
29685 (char *) "self",(char *) "colour", NULL
29686 };
29687
29688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29690 if (SWIG_arg_fail(1)) SWIG_fail;
29691 {
29692 arg2 = &temp2;
29693 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29694 }
29695 {
29696 PyThreadState* __tstate = wxPyBeginAllowThreads();
29697 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29698
29699 wxPyEndAllowThreads(__tstate);
29700 if (PyErr_Occurred()) SWIG_fail;
29701 }
29702 {
29703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29704 }
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj;
29713 wxWindow *arg1 = (wxWindow *) 0 ;
29714 wxColour *arg2 = 0 ;
29715 wxColour temp2 ;
29716 PyObject * obj0 = 0 ;
29717 PyObject * obj1 = 0 ;
29718 char *kwnames[] = {
29719 (char *) "self",(char *) "colour", NULL
29720 };
29721
29722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29724 if (SWIG_arg_fail(1)) SWIG_fail;
29725 {
29726 arg2 = &temp2;
29727 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29728 }
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29732
29733 wxPyEndAllowThreads(__tstate);
29734 if (PyErr_Occurred()) SWIG_fail;
29735 }
29736 Py_INCREF(Py_None); resultobj = Py_None;
29737 return resultobj;
29738 fail:
29739 return NULL;
29740 }
29741
29742
29743 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29744 PyObject *resultobj;
29745 wxWindow *arg1 = (wxWindow *) 0 ;
29746 wxColour result;
29747 PyObject * obj0 = 0 ;
29748 char *kwnames[] = {
29749 (char *) "self", NULL
29750 };
29751
29752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29754 if (SWIG_arg_fail(1)) SWIG_fail;
29755 {
29756 PyThreadState* __tstate = wxPyBeginAllowThreads();
29757 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29758
29759 wxPyEndAllowThreads(__tstate);
29760 if (PyErr_Occurred()) SWIG_fail;
29761 }
29762 {
29763 wxColour * resultptr;
29764 resultptr = new wxColour((wxColour &)(result));
29765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29766 }
29767 return resultobj;
29768 fail:
29769 return NULL;
29770 }
29771
29772
29773 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29774 PyObject *resultobj;
29775 wxWindow *arg1 = (wxWindow *) 0 ;
29776 wxColour result;
29777 PyObject * obj0 = 0 ;
29778 char *kwnames[] = {
29779 (char *) "self", NULL
29780 };
29781
29782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29784 if (SWIG_arg_fail(1)) SWIG_fail;
29785 {
29786 PyThreadState* __tstate = wxPyBeginAllowThreads();
29787 result = ((wxWindow const *)arg1)->GetForegroundColour();
29788
29789 wxPyEndAllowThreads(__tstate);
29790 if (PyErr_Occurred()) SWIG_fail;
29791 }
29792 {
29793 wxColour * resultptr;
29794 resultptr = new wxColour((wxColour &)(result));
29795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29796 }
29797 return resultobj;
29798 fail:
29799 return NULL;
29800 }
29801
29802
29803 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29804 PyObject *resultobj;
29805 wxWindow *arg1 = (wxWindow *) 0 ;
29806 bool result;
29807 PyObject * obj0 = 0 ;
29808 char *kwnames[] = {
29809 (char *) "self", NULL
29810 };
29811
29812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29814 if (SWIG_arg_fail(1)) SWIG_fail;
29815 {
29816 PyThreadState* __tstate = wxPyBeginAllowThreads();
29817 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29818
29819 wxPyEndAllowThreads(__tstate);
29820 if (PyErr_Occurred()) SWIG_fail;
29821 }
29822 {
29823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29824 }
29825 return resultobj;
29826 fail:
29827 return NULL;
29828 }
29829
29830
29831 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29832 PyObject *resultobj;
29833 wxWindow *arg1 = (wxWindow *) 0 ;
29834 bool result;
29835 PyObject * obj0 = 0 ;
29836 char *kwnames[] = {
29837 (char *) "self", NULL
29838 };
29839
29840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29842 if (SWIG_arg_fail(1)) SWIG_fail;
29843 {
29844 PyThreadState* __tstate = wxPyBeginAllowThreads();
29845 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29846
29847 wxPyEndAllowThreads(__tstate);
29848 if (PyErr_Occurred()) SWIG_fail;
29849 }
29850 {
29851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29852 }
29853 return resultobj;
29854 fail:
29855 return NULL;
29856 }
29857
29858
29859 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29860 PyObject *resultobj;
29861 wxWindow *arg1 = (wxWindow *) 0 ;
29862 wxBackgroundStyle arg2 ;
29863 bool result;
29864 PyObject * obj0 = 0 ;
29865 PyObject * obj1 = 0 ;
29866 char *kwnames[] = {
29867 (char *) "self",(char *) "style", NULL
29868 };
29869
29870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29872 if (SWIG_arg_fail(1)) SWIG_fail;
29873 {
29874 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29875 if (SWIG_arg_fail(2)) SWIG_fail;
29876 }
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29880
29881 wxPyEndAllowThreads(__tstate);
29882 if (PyErr_Occurred()) SWIG_fail;
29883 }
29884 {
29885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29886 }
29887 return resultobj;
29888 fail:
29889 return NULL;
29890 }
29891
29892
29893 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29894 PyObject *resultobj;
29895 wxWindow *arg1 = (wxWindow *) 0 ;
29896 wxBackgroundStyle result;
29897 PyObject * obj0 = 0 ;
29898 char *kwnames[] = {
29899 (char *) "self", NULL
29900 };
29901
29902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29904 if (SWIG_arg_fail(1)) SWIG_fail;
29905 {
29906 PyThreadState* __tstate = wxPyBeginAllowThreads();
29907 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29908
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 resultobj = SWIG_From_int((result));
29913 return resultobj;
29914 fail:
29915 return NULL;
29916 }
29917
29918
29919 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29920 PyObject *resultobj;
29921 wxWindow *arg1 = (wxWindow *) 0 ;
29922 bool result;
29923 PyObject * obj0 = 0 ;
29924 char *kwnames[] = {
29925 (char *) "self", NULL
29926 };
29927
29928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29930 if (SWIG_arg_fail(1)) SWIG_fail;
29931 {
29932 PyThreadState* __tstate = wxPyBeginAllowThreads();
29933 result = (bool)(arg1)->HasTransparentBackground();
29934
29935 wxPyEndAllowThreads(__tstate);
29936 if (PyErr_Occurred()) SWIG_fail;
29937 }
29938 {
29939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29940 }
29941 return resultobj;
29942 fail:
29943 return NULL;
29944 }
29945
29946
29947 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29948 PyObject *resultobj;
29949 wxWindow *arg1 = (wxWindow *) 0 ;
29950 wxCursor *arg2 = 0 ;
29951 bool result;
29952 PyObject * obj0 = 0 ;
29953 PyObject * obj1 = 0 ;
29954 char *kwnames[] = {
29955 (char *) "self",(char *) "cursor", NULL
29956 };
29957
29958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29960 if (SWIG_arg_fail(1)) SWIG_fail;
29961 {
29962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29963 if (SWIG_arg_fail(2)) SWIG_fail;
29964 if (arg2 == NULL) {
29965 SWIG_null_ref("wxCursor");
29966 }
29967 if (SWIG_arg_fail(2)) SWIG_fail;
29968 }
29969 {
29970 PyThreadState* __tstate = wxPyBeginAllowThreads();
29971 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29972
29973 wxPyEndAllowThreads(__tstate);
29974 if (PyErr_Occurred()) SWIG_fail;
29975 }
29976 {
29977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29978 }
29979 return resultobj;
29980 fail:
29981 return NULL;
29982 }
29983
29984
29985 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29986 PyObject *resultobj;
29987 wxWindow *arg1 = (wxWindow *) 0 ;
29988 wxCursor result;
29989 PyObject * obj0 = 0 ;
29990 char *kwnames[] = {
29991 (char *) "self", NULL
29992 };
29993
29994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29996 if (SWIG_arg_fail(1)) SWIG_fail;
29997 {
29998 PyThreadState* __tstate = wxPyBeginAllowThreads();
29999 result = (arg1)->GetCursor();
30000
30001 wxPyEndAllowThreads(__tstate);
30002 if (PyErr_Occurred()) SWIG_fail;
30003 }
30004 {
30005 wxCursor * resultptr;
30006 resultptr = new wxCursor((wxCursor &)(result));
30007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30008 }
30009 return resultobj;
30010 fail:
30011 return NULL;
30012 }
30013
30014
30015 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30016 PyObject *resultobj;
30017 wxWindow *arg1 = (wxWindow *) 0 ;
30018 wxFont *arg2 = 0 ;
30019 bool result;
30020 PyObject * obj0 = 0 ;
30021 PyObject * obj1 = 0 ;
30022 char *kwnames[] = {
30023 (char *) "self",(char *) "font", NULL
30024 };
30025
30026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30028 if (SWIG_arg_fail(1)) SWIG_fail;
30029 {
30030 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30031 if (SWIG_arg_fail(2)) SWIG_fail;
30032 if (arg2 == NULL) {
30033 SWIG_null_ref("wxFont");
30034 }
30035 if (SWIG_arg_fail(2)) SWIG_fail;
30036 }
30037 {
30038 PyThreadState* __tstate = wxPyBeginAllowThreads();
30039 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30040
30041 wxPyEndAllowThreads(__tstate);
30042 if (PyErr_Occurred()) SWIG_fail;
30043 }
30044 {
30045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30046 }
30047 return resultobj;
30048 fail:
30049 return NULL;
30050 }
30051
30052
30053 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30054 PyObject *resultobj;
30055 wxWindow *arg1 = (wxWindow *) 0 ;
30056 wxFont *arg2 = 0 ;
30057 PyObject * obj0 = 0 ;
30058 PyObject * obj1 = 0 ;
30059 char *kwnames[] = {
30060 (char *) "self",(char *) "font", NULL
30061 };
30062
30063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30065 if (SWIG_arg_fail(1)) SWIG_fail;
30066 {
30067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30068 if (SWIG_arg_fail(2)) SWIG_fail;
30069 if (arg2 == NULL) {
30070 SWIG_null_ref("wxFont");
30071 }
30072 if (SWIG_arg_fail(2)) SWIG_fail;
30073 }
30074 {
30075 PyThreadState* __tstate = wxPyBeginAllowThreads();
30076 (arg1)->SetOwnFont((wxFont const &)*arg2);
30077
30078 wxPyEndAllowThreads(__tstate);
30079 if (PyErr_Occurred()) SWIG_fail;
30080 }
30081 Py_INCREF(Py_None); resultobj = Py_None;
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30089 PyObject *resultobj;
30090 wxWindow *arg1 = (wxWindow *) 0 ;
30091 wxFont result;
30092 PyObject * obj0 = 0 ;
30093 char *kwnames[] = {
30094 (char *) "self", NULL
30095 };
30096
30097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30099 if (SWIG_arg_fail(1)) SWIG_fail;
30100 {
30101 PyThreadState* __tstate = wxPyBeginAllowThreads();
30102 result = (arg1)->GetFont();
30103
30104 wxPyEndAllowThreads(__tstate);
30105 if (PyErr_Occurred()) SWIG_fail;
30106 }
30107 {
30108 wxFont * resultptr;
30109 resultptr = new wxFont((wxFont &)(result));
30110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30111 }
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj;
30120 wxWindow *arg1 = (wxWindow *) 0 ;
30121 wxCaret *arg2 = (wxCaret *) 0 ;
30122 PyObject * obj0 = 0 ;
30123 PyObject * obj1 = 0 ;
30124 char *kwnames[] = {
30125 (char *) "self",(char *) "caret", NULL
30126 };
30127
30128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30130 if (SWIG_arg_fail(1)) SWIG_fail;
30131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30132 if (SWIG_arg_fail(2)) SWIG_fail;
30133 {
30134 PyThreadState* __tstate = wxPyBeginAllowThreads();
30135 (arg1)->SetCaret(arg2);
30136
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 Py_INCREF(Py_None); resultobj = Py_None;
30141 return resultobj;
30142 fail:
30143 return NULL;
30144 }
30145
30146
30147 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30148 PyObject *resultobj;
30149 wxWindow *arg1 = (wxWindow *) 0 ;
30150 wxCaret *result;
30151 PyObject * obj0 = 0 ;
30152 char *kwnames[] = {
30153 (char *) "self", NULL
30154 };
30155
30156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30158 if (SWIG_arg_fail(1)) SWIG_fail;
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30162
30163 wxPyEndAllowThreads(__tstate);
30164 if (PyErr_Occurred()) SWIG_fail;
30165 }
30166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30167 return resultobj;
30168 fail:
30169 return NULL;
30170 }
30171
30172
30173 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30174 PyObject *resultobj;
30175 wxWindow *arg1 = (wxWindow *) 0 ;
30176 int result;
30177 PyObject * obj0 = 0 ;
30178 char *kwnames[] = {
30179 (char *) "self", NULL
30180 };
30181
30182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30184 if (SWIG_arg_fail(1)) SWIG_fail;
30185 {
30186 PyThreadState* __tstate = wxPyBeginAllowThreads();
30187 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30188
30189 wxPyEndAllowThreads(__tstate);
30190 if (PyErr_Occurred()) SWIG_fail;
30191 }
30192 {
30193 resultobj = SWIG_From_int((int)(result));
30194 }
30195 return resultobj;
30196 fail:
30197 return NULL;
30198 }
30199
30200
30201 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30202 PyObject *resultobj;
30203 wxWindow *arg1 = (wxWindow *) 0 ;
30204 int result;
30205 PyObject * obj0 = 0 ;
30206 char *kwnames[] = {
30207 (char *) "self", NULL
30208 };
30209
30210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30212 if (SWIG_arg_fail(1)) SWIG_fail;
30213 {
30214 PyThreadState* __tstate = wxPyBeginAllowThreads();
30215 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30216
30217 wxPyEndAllowThreads(__tstate);
30218 if (PyErr_Occurred()) SWIG_fail;
30219 }
30220 {
30221 resultobj = SWIG_From_int((int)(result));
30222 }
30223 return resultobj;
30224 fail:
30225 return NULL;
30226 }
30227
30228
30229 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30230 PyObject *resultobj;
30231 wxWindow *arg1 = (wxWindow *) 0 ;
30232 wxString *arg2 = 0 ;
30233 int *arg3 = (int *) 0 ;
30234 int *arg4 = (int *) 0 ;
30235 bool temp2 = false ;
30236 int temp3 ;
30237 int res3 = 0 ;
30238 int temp4 ;
30239 int res4 = 0 ;
30240 PyObject * obj0 = 0 ;
30241 PyObject * obj1 = 0 ;
30242 char *kwnames[] = {
30243 (char *) "self",(char *) "string", NULL
30244 };
30245
30246 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30247 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30250 if (SWIG_arg_fail(1)) SWIG_fail;
30251 {
30252 arg2 = wxString_in_helper(obj1);
30253 if (arg2 == NULL) SWIG_fail;
30254 temp2 = true;
30255 }
30256 {
30257 PyThreadState* __tstate = wxPyBeginAllowThreads();
30258 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30259
30260 wxPyEndAllowThreads(__tstate);
30261 if (PyErr_Occurred()) SWIG_fail;
30262 }
30263 Py_INCREF(Py_None); resultobj = Py_None;
30264 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30265 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30266 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30267 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30268 {
30269 if (temp2)
30270 delete arg2;
30271 }
30272 return resultobj;
30273 fail:
30274 {
30275 if (temp2)
30276 delete arg2;
30277 }
30278 return NULL;
30279 }
30280
30281
30282 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30283 PyObject *resultobj;
30284 wxWindow *arg1 = (wxWindow *) 0 ;
30285 wxString *arg2 = 0 ;
30286 int *arg3 = (int *) 0 ;
30287 int *arg4 = (int *) 0 ;
30288 int *arg5 = (int *) 0 ;
30289 int *arg6 = (int *) 0 ;
30290 wxFont *arg7 = (wxFont *) NULL ;
30291 bool temp2 = false ;
30292 int temp3 ;
30293 int res3 = 0 ;
30294 int temp4 ;
30295 int res4 = 0 ;
30296 int temp5 ;
30297 int res5 = 0 ;
30298 int temp6 ;
30299 int res6 = 0 ;
30300 PyObject * obj0 = 0 ;
30301 PyObject * obj1 = 0 ;
30302 PyObject * obj2 = 0 ;
30303 char *kwnames[] = {
30304 (char *) "self",(char *) "string",(char *) "font", NULL
30305 };
30306
30307 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30308 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30309 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30310 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30313 if (SWIG_arg_fail(1)) SWIG_fail;
30314 {
30315 arg2 = wxString_in_helper(obj1);
30316 if (arg2 == NULL) SWIG_fail;
30317 temp2 = true;
30318 }
30319 if (obj2) {
30320 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30321 if (SWIG_arg_fail(7)) SWIG_fail;
30322 }
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30326
30327 wxPyEndAllowThreads(__tstate);
30328 if (PyErr_Occurred()) SWIG_fail;
30329 }
30330 Py_INCREF(Py_None); resultobj = Py_None;
30331 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30332 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30333 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30334 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30335 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30336 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30337 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30338 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30339 {
30340 if (temp2)
30341 delete arg2;
30342 }
30343 return resultobj;
30344 fail:
30345 {
30346 if (temp2)
30347 delete arg2;
30348 }
30349 return NULL;
30350 }
30351
30352
30353 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30354 PyObject *resultobj;
30355 wxWindow *arg1 = (wxWindow *) 0 ;
30356 int *arg2 = (int *) 0 ;
30357 int *arg3 = (int *) 0 ;
30358 int temp2 ;
30359 int res2 = 0 ;
30360 int temp3 ;
30361 int res3 = 0 ;
30362 PyObject * obj0 = 0 ;
30363 PyObject * obj1 = 0 ;
30364 PyObject * obj2 = 0 ;
30365 char *kwnames[] = {
30366 (char *) "self",(char *) "x",(char *) "y", NULL
30367 };
30368
30369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30371 if (SWIG_arg_fail(1)) SWIG_fail;
30372 {
30373 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30374 temp2 = SWIG_As_int(obj1);
30375 if (SWIG_arg_fail(2)) SWIG_fail;
30376 arg2 = &temp2;
30377 res2 = SWIG_NEWOBJ;
30378 }
30379 }
30380 {
30381 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30382 temp3 = SWIG_As_int(obj2);
30383 if (SWIG_arg_fail(3)) SWIG_fail;
30384 arg3 = &temp3;
30385 res3 = SWIG_NEWOBJ;
30386 }
30387 }
30388 {
30389 PyThreadState* __tstate = wxPyBeginAllowThreads();
30390 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30391
30392 wxPyEndAllowThreads(__tstate);
30393 if (PyErr_Occurred()) SWIG_fail;
30394 }
30395 Py_INCREF(Py_None); resultobj = Py_None;
30396 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30397 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30398 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30399 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30400 return resultobj;
30401 fail:
30402 return NULL;
30403 }
30404
30405
30406 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30407 PyObject *resultobj;
30408 wxWindow *arg1 = (wxWindow *) 0 ;
30409 int *arg2 = (int *) 0 ;
30410 int *arg3 = (int *) 0 ;
30411 int temp2 ;
30412 int res2 = 0 ;
30413 int temp3 ;
30414 int res3 = 0 ;
30415 PyObject * obj0 = 0 ;
30416 PyObject * obj1 = 0 ;
30417 PyObject * obj2 = 0 ;
30418 char *kwnames[] = {
30419 (char *) "self",(char *) "x",(char *) "y", NULL
30420 };
30421
30422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30424 if (SWIG_arg_fail(1)) SWIG_fail;
30425 {
30426 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30427 temp2 = SWIG_As_int(obj1);
30428 if (SWIG_arg_fail(2)) SWIG_fail;
30429 arg2 = &temp2;
30430 res2 = SWIG_NEWOBJ;
30431 }
30432 }
30433 {
30434 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30435 temp3 = SWIG_As_int(obj2);
30436 if (SWIG_arg_fail(3)) SWIG_fail;
30437 arg3 = &temp3;
30438 res3 = SWIG_NEWOBJ;
30439 }
30440 }
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30444
30445 wxPyEndAllowThreads(__tstate);
30446 if (PyErr_Occurred()) SWIG_fail;
30447 }
30448 Py_INCREF(Py_None); resultobj = Py_None;
30449 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30450 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30451 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30452 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj;
30461 wxWindow *arg1 = (wxWindow *) 0 ;
30462 wxPoint *arg2 = 0 ;
30463 wxPoint result;
30464 wxPoint temp2 ;
30465 PyObject * obj0 = 0 ;
30466 PyObject * obj1 = 0 ;
30467 char *kwnames[] = {
30468 (char *) "self",(char *) "pt", NULL
30469 };
30470
30471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
30476 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30477 }
30478 {
30479 PyThreadState* __tstate = wxPyBeginAllowThreads();
30480 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30481
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 {
30486 wxPoint * resultptr;
30487 resultptr = new wxPoint((wxPoint &)(result));
30488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30489 }
30490 return resultobj;
30491 fail:
30492 return NULL;
30493 }
30494
30495
30496 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30497 PyObject *resultobj;
30498 wxWindow *arg1 = (wxWindow *) 0 ;
30499 wxPoint *arg2 = 0 ;
30500 wxPoint result;
30501 wxPoint temp2 ;
30502 PyObject * obj0 = 0 ;
30503 PyObject * obj1 = 0 ;
30504 char *kwnames[] = {
30505 (char *) "self",(char *) "pt", NULL
30506 };
30507
30508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30510 if (SWIG_arg_fail(1)) SWIG_fail;
30511 {
30512 arg2 = &temp2;
30513 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30514 }
30515 {
30516 PyThreadState* __tstate = wxPyBeginAllowThreads();
30517 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30518
30519 wxPyEndAllowThreads(__tstate);
30520 if (PyErr_Occurred()) SWIG_fail;
30521 }
30522 {
30523 wxPoint * resultptr;
30524 resultptr = new wxPoint((wxPoint &)(result));
30525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30526 }
30527 return resultobj;
30528 fail:
30529 return NULL;
30530 }
30531
30532
30533 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30534 PyObject *resultobj;
30535 wxWindow *arg1 = (wxWindow *) 0 ;
30536 int arg2 ;
30537 int arg3 ;
30538 wxHitTest result;
30539 PyObject * obj0 = 0 ;
30540 PyObject * obj1 = 0 ;
30541 PyObject * obj2 = 0 ;
30542 char *kwnames[] = {
30543 (char *) "self",(char *) "x",(char *) "y", NULL
30544 };
30545
30546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30548 if (SWIG_arg_fail(1)) SWIG_fail;
30549 {
30550 arg2 = (int)(SWIG_As_int(obj1));
30551 if (SWIG_arg_fail(2)) SWIG_fail;
30552 }
30553 {
30554 arg3 = (int)(SWIG_As_int(obj2));
30555 if (SWIG_arg_fail(3)) SWIG_fail;
30556 }
30557 {
30558 PyThreadState* __tstate = wxPyBeginAllowThreads();
30559 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30560
30561 wxPyEndAllowThreads(__tstate);
30562 if (PyErr_Occurred()) SWIG_fail;
30563 }
30564 resultobj = SWIG_From_int((result));
30565 return resultobj;
30566 fail:
30567 return NULL;
30568 }
30569
30570
30571 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30572 PyObject *resultobj;
30573 wxWindow *arg1 = (wxWindow *) 0 ;
30574 wxPoint *arg2 = 0 ;
30575 wxHitTest result;
30576 wxPoint temp2 ;
30577 PyObject * obj0 = 0 ;
30578 PyObject * obj1 = 0 ;
30579 char *kwnames[] = {
30580 (char *) "self",(char *) "pt", NULL
30581 };
30582
30583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30585 if (SWIG_arg_fail(1)) SWIG_fail;
30586 {
30587 arg2 = &temp2;
30588 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30589 }
30590 {
30591 PyThreadState* __tstate = wxPyBeginAllowThreads();
30592 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30593
30594 wxPyEndAllowThreads(__tstate);
30595 if (PyErr_Occurred()) SWIG_fail;
30596 }
30597 resultobj = SWIG_From_int((result));
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30605 PyObject *resultobj;
30606 wxWindow *arg1 = (wxWindow *) 0 ;
30607 long arg2 ;
30608 wxBorder result;
30609 PyObject * obj0 = 0 ;
30610 PyObject * obj1 = 0 ;
30611
30612 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30614 if (SWIG_arg_fail(1)) SWIG_fail;
30615 {
30616 arg2 = (long)(SWIG_As_long(obj1));
30617 if (SWIG_arg_fail(2)) SWIG_fail;
30618 }
30619 {
30620 PyThreadState* __tstate = wxPyBeginAllowThreads();
30621 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30622
30623 wxPyEndAllowThreads(__tstate);
30624 if (PyErr_Occurred()) SWIG_fail;
30625 }
30626 resultobj = SWIG_From_int((result));
30627 return resultobj;
30628 fail:
30629 return NULL;
30630 }
30631
30632
30633 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30634 PyObject *resultobj;
30635 wxWindow *arg1 = (wxWindow *) 0 ;
30636 wxBorder result;
30637 PyObject * obj0 = 0 ;
30638
30639 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30641 if (SWIG_arg_fail(1)) SWIG_fail;
30642 {
30643 PyThreadState* __tstate = wxPyBeginAllowThreads();
30644 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30645
30646 wxPyEndAllowThreads(__tstate);
30647 if (PyErr_Occurred()) SWIG_fail;
30648 }
30649 resultobj = SWIG_From_int((result));
30650 return resultobj;
30651 fail:
30652 return NULL;
30653 }
30654
30655
30656 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30657 int argc;
30658 PyObject *argv[3];
30659 int ii;
30660
30661 argc = PyObject_Length(args);
30662 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30663 argv[ii] = PyTuple_GetItem(args,ii);
30664 }
30665 if (argc == 1) {
30666 int _v;
30667 {
30668 void *ptr;
30669 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30670 _v = 0;
30671 PyErr_Clear();
30672 } else {
30673 _v = 1;
30674 }
30675 }
30676 if (_v) {
30677 return _wrap_Window_GetBorder__SWIG_1(self,args);
30678 }
30679 }
30680 if (argc == 2) {
30681 int _v;
30682 {
30683 void *ptr;
30684 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30685 _v = 0;
30686 PyErr_Clear();
30687 } else {
30688 _v = 1;
30689 }
30690 }
30691 if (_v) {
30692 _v = SWIG_Check_long(argv[1]);
30693 if (_v) {
30694 return _wrap_Window_GetBorder__SWIG_0(self,args);
30695 }
30696 }
30697 }
30698
30699 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30700 return NULL;
30701 }
30702
30703
30704 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30705 PyObject *resultobj;
30706 wxWindow *arg1 = (wxWindow *) 0 ;
30707 long arg2 = (long) wxUPDATE_UI_NONE ;
30708 PyObject * obj0 = 0 ;
30709 PyObject * obj1 = 0 ;
30710 char *kwnames[] = {
30711 (char *) "self",(char *) "flags", NULL
30712 };
30713
30714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30716 if (SWIG_arg_fail(1)) SWIG_fail;
30717 if (obj1) {
30718 {
30719 arg2 = (long)(SWIG_As_long(obj1));
30720 if (SWIG_arg_fail(2)) SWIG_fail;
30721 }
30722 }
30723 {
30724 PyThreadState* __tstate = wxPyBeginAllowThreads();
30725 (arg1)->UpdateWindowUI(arg2);
30726
30727 wxPyEndAllowThreads(__tstate);
30728 if (PyErr_Occurred()) SWIG_fail;
30729 }
30730 Py_INCREF(Py_None); resultobj = Py_None;
30731 return resultobj;
30732 fail:
30733 return NULL;
30734 }
30735
30736
30737 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30738 PyObject *resultobj;
30739 wxWindow *arg1 = (wxWindow *) 0 ;
30740 wxMenu *arg2 = (wxMenu *) 0 ;
30741 int arg3 = (int) -1 ;
30742 int arg4 = (int) -1 ;
30743 bool result;
30744 PyObject * obj0 = 0 ;
30745 PyObject * obj1 = 0 ;
30746 PyObject * obj2 = 0 ;
30747 PyObject * obj3 = 0 ;
30748 char *kwnames[] = {
30749 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30750 };
30751
30752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30754 if (SWIG_arg_fail(1)) SWIG_fail;
30755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30756 if (SWIG_arg_fail(2)) SWIG_fail;
30757 if (obj2) {
30758 {
30759 arg3 = (int)(SWIG_As_int(obj2));
30760 if (SWIG_arg_fail(3)) SWIG_fail;
30761 }
30762 }
30763 if (obj3) {
30764 {
30765 arg4 = (int)(SWIG_As_int(obj3));
30766 if (SWIG_arg_fail(4)) SWIG_fail;
30767 }
30768 }
30769 {
30770 PyThreadState* __tstate = wxPyBeginAllowThreads();
30771 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30772
30773 wxPyEndAllowThreads(__tstate);
30774 if (PyErr_Occurred()) SWIG_fail;
30775 }
30776 {
30777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30778 }
30779 return resultobj;
30780 fail:
30781 return NULL;
30782 }
30783
30784
30785 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30786 PyObject *resultobj;
30787 wxWindow *arg1 = (wxWindow *) 0 ;
30788 wxMenu *arg2 = (wxMenu *) 0 ;
30789 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30790 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30791 bool result;
30792 wxPoint temp3 ;
30793 PyObject * obj0 = 0 ;
30794 PyObject * obj1 = 0 ;
30795 PyObject * obj2 = 0 ;
30796 char *kwnames[] = {
30797 (char *) "self",(char *) "menu",(char *) "pos", NULL
30798 };
30799
30800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30802 if (SWIG_arg_fail(1)) SWIG_fail;
30803 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30804 if (SWIG_arg_fail(2)) SWIG_fail;
30805 if (obj2) {
30806 {
30807 arg3 = &temp3;
30808 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30809 }
30810 }
30811 {
30812 PyThreadState* __tstate = wxPyBeginAllowThreads();
30813 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30814
30815 wxPyEndAllowThreads(__tstate);
30816 if (PyErr_Occurred()) SWIG_fail;
30817 }
30818 {
30819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30820 }
30821 return resultobj;
30822 fail:
30823 return NULL;
30824 }
30825
30826
30827 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30828 PyObject *resultobj;
30829 wxWindow *arg1 = (wxWindow *) 0 ;
30830 long result;
30831 PyObject * obj0 = 0 ;
30832 char *kwnames[] = {
30833 (char *) "self", NULL
30834 };
30835
30836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30838 if (SWIG_arg_fail(1)) SWIG_fail;
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 result = (long)wxWindow_GetHandle(arg1);
30842
30843 wxPyEndAllowThreads(__tstate);
30844 if (PyErr_Occurred()) SWIG_fail;
30845 }
30846 {
30847 resultobj = SWIG_From_long((long)(result));
30848 }
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30856 PyObject *resultobj;
30857 wxWindow *arg1 = (wxWindow *) 0 ;
30858 long arg2 ;
30859 PyObject * obj0 = 0 ;
30860 PyObject * obj1 = 0 ;
30861 char *kwnames[] = {
30862 (char *) "self",(char *) "handle", NULL
30863 };
30864
30865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30867 if (SWIG_arg_fail(1)) SWIG_fail;
30868 {
30869 arg2 = (long)(SWIG_As_long(obj1));
30870 if (SWIG_arg_fail(2)) SWIG_fail;
30871 }
30872 {
30873 PyThreadState* __tstate = wxPyBeginAllowThreads();
30874 wxWindow_AssociateHandle(arg1,arg2);
30875
30876 wxPyEndAllowThreads(__tstate);
30877 if (PyErr_Occurred()) SWIG_fail;
30878 }
30879 Py_INCREF(Py_None); resultobj = Py_None;
30880 return resultobj;
30881 fail:
30882 return NULL;
30883 }
30884
30885
30886 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30887 PyObject *resultobj;
30888 wxWindow *arg1 = (wxWindow *) 0 ;
30889 PyObject * obj0 = 0 ;
30890 char *kwnames[] = {
30891 (char *) "self", NULL
30892 };
30893
30894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30896 if (SWIG_arg_fail(1)) SWIG_fail;
30897 {
30898 PyThreadState* __tstate = wxPyBeginAllowThreads();
30899 (arg1)->DissociateHandle();
30900
30901 wxPyEndAllowThreads(__tstate);
30902 if (PyErr_Occurred()) SWIG_fail;
30903 }
30904 Py_INCREF(Py_None); resultobj = Py_None;
30905 return resultobj;
30906 fail:
30907 return NULL;
30908 }
30909
30910
30911 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30912 PyObject *resultobj;
30913 wxWindow *arg1 = (wxWindow *) 0 ;
30914 wxPaintEvent *arg2 = 0 ;
30915 PyObject * obj0 = 0 ;
30916 PyObject * obj1 = 0 ;
30917 char *kwnames[] = {
30918 (char *) "self",(char *) "event", NULL
30919 };
30920
30921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30923 if (SWIG_arg_fail(1)) SWIG_fail;
30924 {
30925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30926 if (SWIG_arg_fail(2)) SWIG_fail;
30927 if (arg2 == NULL) {
30928 SWIG_null_ref("wxPaintEvent");
30929 }
30930 if (SWIG_arg_fail(2)) SWIG_fail;
30931 }
30932 {
30933 PyThreadState* __tstate = wxPyBeginAllowThreads();
30934 (arg1)->OnPaint(*arg2);
30935
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 Py_INCREF(Py_None); resultobj = Py_None;
30940 return resultobj;
30941 fail:
30942 return NULL;
30943 }
30944
30945
30946 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30947 PyObject *resultobj;
30948 wxWindow *arg1 = (wxWindow *) 0 ;
30949 int arg2 ;
30950 bool result;
30951 PyObject * obj0 = 0 ;
30952 PyObject * obj1 = 0 ;
30953 char *kwnames[] = {
30954 (char *) "self",(char *) "orient", NULL
30955 };
30956
30957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30959 if (SWIG_arg_fail(1)) SWIG_fail;
30960 {
30961 arg2 = (int)(SWIG_As_int(obj1));
30962 if (SWIG_arg_fail(2)) SWIG_fail;
30963 }
30964 {
30965 PyThreadState* __tstate = wxPyBeginAllowThreads();
30966 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30967
30968 wxPyEndAllowThreads(__tstate);
30969 if (PyErr_Occurred()) SWIG_fail;
30970 }
30971 {
30972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30973 }
30974 return resultobj;
30975 fail:
30976 return NULL;
30977 }
30978
30979
30980 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30981 PyObject *resultobj;
30982 wxWindow *arg1 = (wxWindow *) 0 ;
30983 int arg2 ;
30984 int arg3 ;
30985 int arg4 ;
30986 int arg5 ;
30987 bool arg6 = (bool) true ;
30988 PyObject * obj0 = 0 ;
30989 PyObject * obj1 = 0 ;
30990 PyObject * obj2 = 0 ;
30991 PyObject * obj3 = 0 ;
30992 PyObject * obj4 = 0 ;
30993 PyObject * obj5 = 0 ;
30994 char *kwnames[] = {
30995 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30996 };
30997
30998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31000 if (SWIG_arg_fail(1)) SWIG_fail;
31001 {
31002 arg2 = (int)(SWIG_As_int(obj1));
31003 if (SWIG_arg_fail(2)) SWIG_fail;
31004 }
31005 {
31006 arg3 = (int)(SWIG_As_int(obj2));
31007 if (SWIG_arg_fail(3)) SWIG_fail;
31008 }
31009 {
31010 arg4 = (int)(SWIG_As_int(obj3));
31011 if (SWIG_arg_fail(4)) SWIG_fail;
31012 }
31013 {
31014 arg5 = (int)(SWIG_As_int(obj4));
31015 if (SWIG_arg_fail(5)) SWIG_fail;
31016 }
31017 if (obj5) {
31018 {
31019 arg6 = (bool)(SWIG_As_bool(obj5));
31020 if (SWIG_arg_fail(6)) SWIG_fail;
31021 }
31022 }
31023 {
31024 PyThreadState* __tstate = wxPyBeginAllowThreads();
31025 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31026
31027 wxPyEndAllowThreads(__tstate);
31028 if (PyErr_Occurred()) SWIG_fail;
31029 }
31030 Py_INCREF(Py_None); resultobj = Py_None;
31031 return resultobj;
31032 fail:
31033 return NULL;
31034 }
31035
31036
31037 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31038 PyObject *resultobj;
31039 wxWindow *arg1 = (wxWindow *) 0 ;
31040 int arg2 ;
31041 int arg3 ;
31042 bool arg4 = (bool) true ;
31043 PyObject * obj0 = 0 ;
31044 PyObject * obj1 = 0 ;
31045 PyObject * obj2 = 0 ;
31046 PyObject * obj3 = 0 ;
31047 char *kwnames[] = {
31048 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31049 };
31050
31051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31053 if (SWIG_arg_fail(1)) SWIG_fail;
31054 {
31055 arg2 = (int)(SWIG_As_int(obj1));
31056 if (SWIG_arg_fail(2)) SWIG_fail;
31057 }
31058 {
31059 arg3 = (int)(SWIG_As_int(obj2));
31060 if (SWIG_arg_fail(3)) SWIG_fail;
31061 }
31062 if (obj3) {
31063 {
31064 arg4 = (bool)(SWIG_As_bool(obj3));
31065 if (SWIG_arg_fail(4)) SWIG_fail;
31066 }
31067 }
31068 {
31069 PyThreadState* __tstate = wxPyBeginAllowThreads();
31070 (arg1)->SetScrollPos(arg2,arg3,arg4);
31071
31072 wxPyEndAllowThreads(__tstate);
31073 if (PyErr_Occurred()) SWIG_fail;
31074 }
31075 Py_INCREF(Py_None); resultobj = Py_None;
31076 return resultobj;
31077 fail:
31078 return NULL;
31079 }
31080
31081
31082 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31083 PyObject *resultobj;
31084 wxWindow *arg1 = (wxWindow *) 0 ;
31085 int arg2 ;
31086 int result;
31087 PyObject * obj0 = 0 ;
31088 PyObject * obj1 = 0 ;
31089 char *kwnames[] = {
31090 (char *) "self",(char *) "orientation", NULL
31091 };
31092
31093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31095 if (SWIG_arg_fail(1)) SWIG_fail;
31096 {
31097 arg2 = (int)(SWIG_As_int(obj1));
31098 if (SWIG_arg_fail(2)) SWIG_fail;
31099 }
31100 {
31101 PyThreadState* __tstate = wxPyBeginAllowThreads();
31102 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31103
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 {
31108 resultobj = SWIG_From_int((int)(result));
31109 }
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31117 PyObject *resultobj;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 int arg2 ;
31120 int result;
31121 PyObject * obj0 = 0 ;
31122 PyObject * obj1 = 0 ;
31123 char *kwnames[] = {
31124 (char *) "self",(char *) "orientation", NULL
31125 };
31126
31127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31129 if (SWIG_arg_fail(1)) SWIG_fail;
31130 {
31131 arg2 = (int)(SWIG_As_int(obj1));
31132 if (SWIG_arg_fail(2)) SWIG_fail;
31133 }
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31137
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 {
31142 resultobj = SWIG_From_int((int)(result));
31143 }
31144 return resultobj;
31145 fail:
31146 return NULL;
31147 }
31148
31149
31150 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31151 PyObject *resultobj;
31152 wxWindow *arg1 = (wxWindow *) 0 ;
31153 int arg2 ;
31154 int result;
31155 PyObject * obj0 = 0 ;
31156 PyObject * obj1 = 0 ;
31157 char *kwnames[] = {
31158 (char *) "self",(char *) "orientation", NULL
31159 };
31160
31161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31163 if (SWIG_arg_fail(1)) SWIG_fail;
31164 {
31165 arg2 = (int)(SWIG_As_int(obj1));
31166 if (SWIG_arg_fail(2)) SWIG_fail;
31167 }
31168 {
31169 PyThreadState* __tstate = wxPyBeginAllowThreads();
31170 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31171
31172 wxPyEndAllowThreads(__tstate);
31173 if (PyErr_Occurred()) SWIG_fail;
31174 }
31175 {
31176 resultobj = SWIG_From_int((int)(result));
31177 }
31178 return resultobj;
31179 fail:
31180 return NULL;
31181 }
31182
31183
31184 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31185 PyObject *resultobj;
31186 wxWindow *arg1 = (wxWindow *) 0 ;
31187 int arg2 ;
31188 int arg3 ;
31189 wxRect *arg4 = (wxRect *) NULL ;
31190 PyObject * obj0 = 0 ;
31191 PyObject * obj1 = 0 ;
31192 PyObject * obj2 = 0 ;
31193 PyObject * obj3 = 0 ;
31194 char *kwnames[] = {
31195 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31196 };
31197
31198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31200 if (SWIG_arg_fail(1)) SWIG_fail;
31201 {
31202 arg2 = (int)(SWIG_As_int(obj1));
31203 if (SWIG_arg_fail(2)) SWIG_fail;
31204 }
31205 {
31206 arg3 = (int)(SWIG_As_int(obj2));
31207 if (SWIG_arg_fail(3)) SWIG_fail;
31208 }
31209 if (obj3) {
31210 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31211 if (SWIG_arg_fail(4)) SWIG_fail;
31212 }
31213 {
31214 PyThreadState* __tstate = wxPyBeginAllowThreads();
31215 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31216
31217 wxPyEndAllowThreads(__tstate);
31218 if (PyErr_Occurred()) SWIG_fail;
31219 }
31220 Py_INCREF(Py_None); resultobj = Py_None;
31221 return resultobj;
31222 fail:
31223 return NULL;
31224 }
31225
31226
31227 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31228 PyObject *resultobj;
31229 wxWindow *arg1 = (wxWindow *) 0 ;
31230 int arg2 ;
31231 bool result;
31232 PyObject * obj0 = 0 ;
31233 PyObject * obj1 = 0 ;
31234 char *kwnames[] = {
31235 (char *) "self",(char *) "lines", NULL
31236 };
31237
31238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31240 if (SWIG_arg_fail(1)) SWIG_fail;
31241 {
31242 arg2 = (int)(SWIG_As_int(obj1));
31243 if (SWIG_arg_fail(2)) SWIG_fail;
31244 }
31245 {
31246 PyThreadState* __tstate = wxPyBeginAllowThreads();
31247 result = (bool)(arg1)->ScrollLines(arg2);
31248
31249 wxPyEndAllowThreads(__tstate);
31250 if (PyErr_Occurred()) SWIG_fail;
31251 }
31252 {
31253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31254 }
31255 return resultobj;
31256 fail:
31257 return NULL;
31258 }
31259
31260
31261 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31262 PyObject *resultobj;
31263 wxWindow *arg1 = (wxWindow *) 0 ;
31264 int arg2 ;
31265 bool result;
31266 PyObject * obj0 = 0 ;
31267 PyObject * obj1 = 0 ;
31268 char *kwnames[] = {
31269 (char *) "self",(char *) "pages", NULL
31270 };
31271
31272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31274 if (SWIG_arg_fail(1)) SWIG_fail;
31275 {
31276 arg2 = (int)(SWIG_As_int(obj1));
31277 if (SWIG_arg_fail(2)) SWIG_fail;
31278 }
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 result = (bool)(arg1)->ScrollPages(arg2);
31282
31283 wxPyEndAllowThreads(__tstate);
31284 if (PyErr_Occurred()) SWIG_fail;
31285 }
31286 {
31287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31288 }
31289 return resultobj;
31290 fail:
31291 return NULL;
31292 }
31293
31294
31295 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31296 PyObject *resultobj;
31297 wxWindow *arg1 = (wxWindow *) 0 ;
31298 bool result;
31299 PyObject * obj0 = 0 ;
31300 char *kwnames[] = {
31301 (char *) "self", NULL
31302 };
31303
31304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31306 if (SWIG_arg_fail(1)) SWIG_fail;
31307 {
31308 PyThreadState* __tstate = wxPyBeginAllowThreads();
31309 result = (bool)(arg1)->LineUp();
31310
31311 wxPyEndAllowThreads(__tstate);
31312 if (PyErr_Occurred()) SWIG_fail;
31313 }
31314 {
31315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31316 }
31317 return resultobj;
31318 fail:
31319 return NULL;
31320 }
31321
31322
31323 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31324 PyObject *resultobj;
31325 wxWindow *arg1 = (wxWindow *) 0 ;
31326 bool result;
31327 PyObject * obj0 = 0 ;
31328 char *kwnames[] = {
31329 (char *) "self", NULL
31330 };
31331
31332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31334 if (SWIG_arg_fail(1)) SWIG_fail;
31335 {
31336 PyThreadState* __tstate = wxPyBeginAllowThreads();
31337 result = (bool)(arg1)->LineDown();
31338
31339 wxPyEndAllowThreads(__tstate);
31340 if (PyErr_Occurred()) SWIG_fail;
31341 }
31342 {
31343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31344 }
31345 return resultobj;
31346 fail:
31347 return NULL;
31348 }
31349
31350
31351 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31352 PyObject *resultobj;
31353 wxWindow *arg1 = (wxWindow *) 0 ;
31354 bool result;
31355 PyObject * obj0 = 0 ;
31356 char *kwnames[] = {
31357 (char *) "self", NULL
31358 };
31359
31360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31362 if (SWIG_arg_fail(1)) SWIG_fail;
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 result = (bool)(arg1)->PageUp();
31366
31367 wxPyEndAllowThreads(__tstate);
31368 if (PyErr_Occurred()) SWIG_fail;
31369 }
31370 {
31371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31372 }
31373 return resultobj;
31374 fail:
31375 return NULL;
31376 }
31377
31378
31379 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31380 PyObject *resultobj;
31381 wxWindow *arg1 = (wxWindow *) 0 ;
31382 bool result;
31383 PyObject * obj0 = 0 ;
31384 char *kwnames[] = {
31385 (char *) "self", NULL
31386 };
31387
31388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31390 if (SWIG_arg_fail(1)) SWIG_fail;
31391 {
31392 PyThreadState* __tstate = wxPyBeginAllowThreads();
31393 result = (bool)(arg1)->PageDown();
31394
31395 wxPyEndAllowThreads(__tstate);
31396 if (PyErr_Occurred()) SWIG_fail;
31397 }
31398 {
31399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31400 }
31401 return resultobj;
31402 fail:
31403 return NULL;
31404 }
31405
31406
31407 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31408 PyObject *resultobj;
31409 wxWindow *arg1 = (wxWindow *) 0 ;
31410 wxString *arg2 = 0 ;
31411 bool temp2 = false ;
31412 PyObject * obj0 = 0 ;
31413 PyObject * obj1 = 0 ;
31414 char *kwnames[] = {
31415 (char *) "self",(char *) "text", NULL
31416 };
31417
31418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31420 if (SWIG_arg_fail(1)) SWIG_fail;
31421 {
31422 arg2 = wxString_in_helper(obj1);
31423 if (arg2 == NULL) SWIG_fail;
31424 temp2 = true;
31425 }
31426 {
31427 PyThreadState* __tstate = wxPyBeginAllowThreads();
31428 (arg1)->SetHelpText((wxString const &)*arg2);
31429
31430 wxPyEndAllowThreads(__tstate);
31431 if (PyErr_Occurred()) SWIG_fail;
31432 }
31433 Py_INCREF(Py_None); resultobj = Py_None;
31434 {
31435 if (temp2)
31436 delete arg2;
31437 }
31438 return resultobj;
31439 fail:
31440 {
31441 if (temp2)
31442 delete arg2;
31443 }
31444 return NULL;
31445 }
31446
31447
31448 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31449 PyObject *resultobj;
31450 wxWindow *arg1 = (wxWindow *) 0 ;
31451 wxString *arg2 = 0 ;
31452 bool temp2 = false ;
31453 PyObject * obj0 = 0 ;
31454 PyObject * obj1 = 0 ;
31455 char *kwnames[] = {
31456 (char *) "self",(char *) "text", NULL
31457 };
31458
31459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(1)) SWIG_fail;
31462 {
31463 arg2 = wxString_in_helper(obj1);
31464 if (arg2 == NULL) SWIG_fail;
31465 temp2 = true;
31466 }
31467 {
31468 PyThreadState* __tstate = wxPyBeginAllowThreads();
31469 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31470
31471 wxPyEndAllowThreads(__tstate);
31472 if (PyErr_Occurred()) SWIG_fail;
31473 }
31474 Py_INCREF(Py_None); resultobj = Py_None;
31475 {
31476 if (temp2)
31477 delete arg2;
31478 }
31479 return resultobj;
31480 fail:
31481 {
31482 if (temp2)
31483 delete arg2;
31484 }
31485 return NULL;
31486 }
31487
31488
31489 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31490 PyObject *resultobj;
31491 wxWindow *arg1 = (wxWindow *) 0 ;
31492 wxString result;
31493 PyObject * obj0 = 0 ;
31494 char *kwnames[] = {
31495 (char *) "self", NULL
31496 };
31497
31498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31500 if (SWIG_arg_fail(1)) SWIG_fail;
31501 {
31502 PyThreadState* __tstate = wxPyBeginAllowThreads();
31503 result = ((wxWindow const *)arg1)->GetHelpText();
31504
31505 wxPyEndAllowThreads(__tstate);
31506 if (PyErr_Occurred()) SWIG_fail;
31507 }
31508 {
31509 #if wxUSE_UNICODE
31510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31511 #else
31512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31513 #endif
31514 }
31515 return resultobj;
31516 fail:
31517 return NULL;
31518 }
31519
31520
31521 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31522 PyObject *resultobj;
31523 wxWindow *arg1 = (wxWindow *) 0 ;
31524 wxString *arg2 = 0 ;
31525 bool temp2 = false ;
31526 PyObject * obj0 = 0 ;
31527 PyObject * obj1 = 0 ;
31528 char *kwnames[] = {
31529 (char *) "self",(char *) "tip", NULL
31530 };
31531
31532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31534 if (SWIG_arg_fail(1)) SWIG_fail;
31535 {
31536 arg2 = wxString_in_helper(obj1);
31537 if (arg2 == NULL) SWIG_fail;
31538 temp2 = true;
31539 }
31540 {
31541 PyThreadState* __tstate = wxPyBeginAllowThreads();
31542 (arg1)->SetToolTip((wxString const &)*arg2);
31543
31544 wxPyEndAllowThreads(__tstate);
31545 if (PyErr_Occurred()) SWIG_fail;
31546 }
31547 Py_INCREF(Py_None); resultobj = Py_None;
31548 {
31549 if (temp2)
31550 delete arg2;
31551 }
31552 return resultobj;
31553 fail:
31554 {
31555 if (temp2)
31556 delete arg2;
31557 }
31558 return NULL;
31559 }
31560
31561
31562 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31563 PyObject *resultobj;
31564 wxWindow *arg1 = (wxWindow *) 0 ;
31565 wxToolTip *arg2 = (wxToolTip *) 0 ;
31566 PyObject * obj0 = 0 ;
31567 PyObject * obj1 = 0 ;
31568 char *kwnames[] = {
31569 (char *) "self",(char *) "tip", NULL
31570 };
31571
31572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31574 if (SWIG_arg_fail(1)) SWIG_fail;
31575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31576 if (SWIG_arg_fail(2)) SWIG_fail;
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 (arg1)->SetToolTip(arg2);
31580
31581 wxPyEndAllowThreads(__tstate);
31582 if (PyErr_Occurred()) SWIG_fail;
31583 }
31584 Py_INCREF(Py_None); resultobj = Py_None;
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31592 PyObject *resultobj;
31593 wxWindow *arg1 = (wxWindow *) 0 ;
31594 wxToolTip *result;
31595 PyObject * obj0 = 0 ;
31596 char *kwnames[] = {
31597 (char *) "self", NULL
31598 };
31599
31600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31602 if (SWIG_arg_fail(1)) SWIG_fail;
31603 {
31604 PyThreadState* __tstate = wxPyBeginAllowThreads();
31605 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31606
31607 wxPyEndAllowThreads(__tstate);
31608 if (PyErr_Occurred()) SWIG_fail;
31609 }
31610 {
31611 resultobj = wxPyMake_wxObject(result, 0);
31612 }
31613 return resultobj;
31614 fail:
31615 return NULL;
31616 }
31617
31618
31619 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31620 PyObject *resultobj;
31621 wxWindow *arg1 = (wxWindow *) 0 ;
31622 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31623 PyObject * obj0 = 0 ;
31624 PyObject * obj1 = 0 ;
31625 char *kwnames[] = {
31626 (char *) "self",(char *) "dropTarget", NULL
31627 };
31628
31629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31631 if (SWIG_arg_fail(1)) SWIG_fail;
31632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31633 if (SWIG_arg_fail(2)) SWIG_fail;
31634 {
31635 PyThreadState* __tstate = wxPyBeginAllowThreads();
31636 (arg1)->SetDropTarget(arg2);
31637
31638 wxPyEndAllowThreads(__tstate);
31639 if (PyErr_Occurred()) SWIG_fail;
31640 }
31641 Py_INCREF(Py_None); resultobj = Py_None;
31642 return resultobj;
31643 fail:
31644 return NULL;
31645 }
31646
31647
31648 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31649 PyObject *resultobj;
31650 wxWindow *arg1 = (wxWindow *) 0 ;
31651 wxPyDropTarget *result;
31652 PyObject * obj0 = 0 ;
31653 char *kwnames[] = {
31654 (char *) "self", NULL
31655 };
31656
31657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31659 if (SWIG_arg_fail(1)) SWIG_fail;
31660 {
31661 PyThreadState* __tstate = wxPyBeginAllowThreads();
31662 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31663
31664 wxPyEndAllowThreads(__tstate);
31665 if (PyErr_Occurred()) SWIG_fail;
31666 }
31667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31668 return resultobj;
31669 fail:
31670 return NULL;
31671 }
31672
31673
31674 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31675 PyObject *resultobj;
31676 wxWindow *arg1 = (wxWindow *) 0 ;
31677 bool arg2 ;
31678 PyObject * obj0 = 0 ;
31679 PyObject * obj1 = 0 ;
31680 char *kwnames[] = {
31681 (char *) "self",(char *) "accept", NULL
31682 };
31683
31684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31686 if (SWIG_arg_fail(1)) SWIG_fail;
31687 {
31688 arg2 = (bool)(SWIG_As_bool(obj1));
31689 if (SWIG_arg_fail(2)) SWIG_fail;
31690 }
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 (arg1)->DragAcceptFiles(arg2);
31694
31695 wxPyEndAllowThreads(__tstate);
31696 if (PyErr_Occurred()) SWIG_fail;
31697 }
31698 Py_INCREF(Py_None); resultobj = Py_None;
31699 return resultobj;
31700 fail:
31701 return NULL;
31702 }
31703
31704
31705 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31706 PyObject *resultobj;
31707 wxWindow *arg1 = (wxWindow *) 0 ;
31708 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31709 PyObject * obj0 = 0 ;
31710 PyObject * obj1 = 0 ;
31711 char *kwnames[] = {
31712 (char *) "self",(char *) "constraints", NULL
31713 };
31714
31715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31717 if (SWIG_arg_fail(1)) SWIG_fail;
31718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31719 if (SWIG_arg_fail(2)) SWIG_fail;
31720 {
31721 PyThreadState* __tstate = wxPyBeginAllowThreads();
31722 (arg1)->SetConstraints(arg2);
31723
31724 wxPyEndAllowThreads(__tstate);
31725 if (PyErr_Occurred()) SWIG_fail;
31726 }
31727 Py_INCREF(Py_None); resultobj = Py_None;
31728 return resultobj;
31729 fail:
31730 return NULL;
31731 }
31732
31733
31734 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31735 PyObject *resultobj;
31736 wxWindow *arg1 = (wxWindow *) 0 ;
31737 wxLayoutConstraints *result;
31738 PyObject * obj0 = 0 ;
31739 char *kwnames[] = {
31740 (char *) "self", NULL
31741 };
31742
31743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31745 if (SWIG_arg_fail(1)) SWIG_fail;
31746 {
31747 PyThreadState* __tstate = wxPyBeginAllowThreads();
31748 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31749
31750 wxPyEndAllowThreads(__tstate);
31751 if (PyErr_Occurred()) SWIG_fail;
31752 }
31753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31754 return resultobj;
31755 fail:
31756 return NULL;
31757 }
31758
31759
31760 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31761 PyObject *resultobj;
31762 wxWindow *arg1 = (wxWindow *) 0 ;
31763 bool arg2 ;
31764 PyObject * obj0 = 0 ;
31765 PyObject * obj1 = 0 ;
31766 char *kwnames[] = {
31767 (char *) "self",(char *) "autoLayout", NULL
31768 };
31769
31770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31772 if (SWIG_arg_fail(1)) SWIG_fail;
31773 {
31774 arg2 = (bool)(SWIG_As_bool(obj1));
31775 if (SWIG_arg_fail(2)) SWIG_fail;
31776 }
31777 {
31778 PyThreadState* __tstate = wxPyBeginAllowThreads();
31779 (arg1)->SetAutoLayout(arg2);
31780
31781 wxPyEndAllowThreads(__tstate);
31782 if (PyErr_Occurred()) SWIG_fail;
31783 }
31784 Py_INCREF(Py_None); resultobj = Py_None;
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31792 PyObject *resultobj;
31793 wxWindow *arg1 = (wxWindow *) 0 ;
31794 bool result;
31795 PyObject * obj0 = 0 ;
31796 char *kwnames[] = {
31797 (char *) "self", NULL
31798 };
31799
31800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31802 if (SWIG_arg_fail(1)) SWIG_fail;
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31806
31807 wxPyEndAllowThreads(__tstate);
31808 if (PyErr_Occurred()) SWIG_fail;
31809 }
31810 {
31811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31812 }
31813 return resultobj;
31814 fail:
31815 return NULL;
31816 }
31817
31818
31819 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31820 PyObject *resultobj;
31821 wxWindow *arg1 = (wxWindow *) 0 ;
31822 bool result;
31823 PyObject * obj0 = 0 ;
31824 char *kwnames[] = {
31825 (char *) "self", NULL
31826 };
31827
31828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31830 if (SWIG_arg_fail(1)) SWIG_fail;
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 result = (bool)(arg1)->Layout();
31834
31835 wxPyEndAllowThreads(__tstate);
31836 if (PyErr_Occurred()) SWIG_fail;
31837 }
31838 {
31839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31840 }
31841 return resultobj;
31842 fail:
31843 return NULL;
31844 }
31845
31846
31847 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31848 PyObject *resultobj;
31849 wxWindow *arg1 = (wxWindow *) 0 ;
31850 wxSizer *arg2 = (wxSizer *) 0 ;
31851 bool arg3 = (bool) true ;
31852 PyObject * obj0 = 0 ;
31853 PyObject * obj1 = 0 ;
31854 PyObject * obj2 = 0 ;
31855 char *kwnames[] = {
31856 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31857 };
31858
31859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31861 if (SWIG_arg_fail(1)) SWIG_fail;
31862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31863 if (SWIG_arg_fail(2)) SWIG_fail;
31864 if (obj2) {
31865 {
31866 arg3 = (bool)(SWIG_As_bool(obj2));
31867 if (SWIG_arg_fail(3)) SWIG_fail;
31868 }
31869 }
31870 {
31871 PyThreadState* __tstate = wxPyBeginAllowThreads();
31872 (arg1)->SetSizer(arg2,arg3);
31873
31874 wxPyEndAllowThreads(__tstate);
31875 if (PyErr_Occurred()) SWIG_fail;
31876 }
31877 Py_INCREF(Py_None); resultobj = Py_None;
31878 return resultobj;
31879 fail:
31880 return NULL;
31881 }
31882
31883
31884 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31885 PyObject *resultobj;
31886 wxWindow *arg1 = (wxWindow *) 0 ;
31887 wxSizer *arg2 = (wxSizer *) 0 ;
31888 bool arg3 = (bool) true ;
31889 PyObject * obj0 = 0 ;
31890 PyObject * obj1 = 0 ;
31891 PyObject * obj2 = 0 ;
31892 char *kwnames[] = {
31893 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31894 };
31895
31896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31898 if (SWIG_arg_fail(1)) SWIG_fail;
31899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31900 if (SWIG_arg_fail(2)) SWIG_fail;
31901 if (obj2) {
31902 {
31903 arg3 = (bool)(SWIG_As_bool(obj2));
31904 if (SWIG_arg_fail(3)) SWIG_fail;
31905 }
31906 }
31907 {
31908 PyThreadState* __tstate = wxPyBeginAllowThreads();
31909 (arg1)->SetSizerAndFit(arg2,arg3);
31910
31911 wxPyEndAllowThreads(__tstate);
31912 if (PyErr_Occurred()) SWIG_fail;
31913 }
31914 Py_INCREF(Py_None); resultobj = Py_None;
31915 return resultobj;
31916 fail:
31917 return NULL;
31918 }
31919
31920
31921 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31922 PyObject *resultobj;
31923 wxWindow *arg1 = (wxWindow *) 0 ;
31924 wxSizer *result;
31925 PyObject * obj0 = 0 ;
31926 char *kwnames[] = {
31927 (char *) "self", NULL
31928 };
31929
31930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31932 if (SWIG_arg_fail(1)) SWIG_fail;
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31936
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 {
31941 resultobj = wxPyMake_wxSizer(result, 0);
31942 }
31943 return resultobj;
31944 fail:
31945 return NULL;
31946 }
31947
31948
31949 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31950 PyObject *resultobj;
31951 wxWindow *arg1 = (wxWindow *) 0 ;
31952 wxSizer *arg2 = (wxSizer *) 0 ;
31953 PyObject * obj0 = 0 ;
31954 PyObject * obj1 = 0 ;
31955 char *kwnames[] = {
31956 (char *) "self",(char *) "sizer", NULL
31957 };
31958
31959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31961 if (SWIG_arg_fail(1)) SWIG_fail;
31962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31963 if (SWIG_arg_fail(2)) SWIG_fail;
31964 {
31965 PyThreadState* __tstate = wxPyBeginAllowThreads();
31966 (arg1)->SetContainingSizer(arg2);
31967
31968 wxPyEndAllowThreads(__tstate);
31969 if (PyErr_Occurred()) SWIG_fail;
31970 }
31971 Py_INCREF(Py_None); resultobj = Py_None;
31972 return resultobj;
31973 fail:
31974 return NULL;
31975 }
31976
31977
31978 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31979 PyObject *resultobj;
31980 wxWindow *arg1 = (wxWindow *) 0 ;
31981 wxSizer *result;
31982 PyObject * obj0 = 0 ;
31983 char *kwnames[] = {
31984 (char *) "self", NULL
31985 };
31986
31987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31989 if (SWIG_arg_fail(1)) SWIG_fail;
31990 {
31991 PyThreadState* __tstate = wxPyBeginAllowThreads();
31992 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31993
31994 wxPyEndAllowThreads(__tstate);
31995 if (PyErr_Occurred()) SWIG_fail;
31996 }
31997 {
31998 resultobj = wxPyMake_wxSizer(result, 0);
31999 }
32000 return resultobj;
32001 fail:
32002 return NULL;
32003 }
32004
32005
32006 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32007 PyObject *resultobj;
32008 wxWindow *arg1 = (wxWindow *) 0 ;
32009 PyObject * obj0 = 0 ;
32010 char *kwnames[] = {
32011 (char *) "self", NULL
32012 };
32013
32014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32016 if (SWIG_arg_fail(1)) SWIG_fail;
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 (arg1)->InheritAttributes();
32020
32021 wxPyEndAllowThreads(__tstate);
32022 if (PyErr_Occurred()) SWIG_fail;
32023 }
32024 Py_INCREF(Py_None); resultobj = Py_None;
32025 return resultobj;
32026 fail:
32027 return NULL;
32028 }
32029
32030
32031 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32032 PyObject *resultobj;
32033 wxWindow *arg1 = (wxWindow *) 0 ;
32034 bool result;
32035 PyObject * obj0 = 0 ;
32036 char *kwnames[] = {
32037 (char *) "self", NULL
32038 };
32039
32040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32042 if (SWIG_arg_fail(1)) SWIG_fail;
32043 {
32044 PyThreadState* __tstate = wxPyBeginAllowThreads();
32045 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32046
32047 wxPyEndAllowThreads(__tstate);
32048 if (PyErr_Occurred()) SWIG_fail;
32049 }
32050 {
32051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32052 }
32053 return resultobj;
32054 fail:
32055 return NULL;
32056 }
32057
32058
32059 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32060 PyObject *obj;
32061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32062 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32063 Py_INCREF(obj);
32064 return Py_BuildValue((char *)"");
32065 }
32066 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32067 PyObject *resultobj;
32068 long arg1 ;
32069 wxWindow *arg2 = (wxWindow *) NULL ;
32070 wxWindow *result;
32071 PyObject * obj0 = 0 ;
32072 PyObject * obj1 = 0 ;
32073 char *kwnames[] = {
32074 (char *) "id",(char *) "parent", NULL
32075 };
32076
32077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32078 {
32079 arg1 = (long)(SWIG_As_long(obj0));
32080 if (SWIG_arg_fail(1)) SWIG_fail;
32081 }
32082 if (obj1) {
32083 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32084 if (SWIG_arg_fail(2)) SWIG_fail;
32085 }
32086 {
32087 if (!wxPyCheckForApp()) SWIG_fail;
32088 PyThreadState* __tstate = wxPyBeginAllowThreads();
32089 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32090
32091 wxPyEndAllowThreads(__tstate);
32092 if (PyErr_Occurred()) SWIG_fail;
32093 }
32094 {
32095 resultobj = wxPyMake_wxObject(result, 0);
32096 }
32097 return resultobj;
32098 fail:
32099 return NULL;
32100 }
32101
32102
32103 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32104 PyObject *resultobj;
32105 wxString *arg1 = 0 ;
32106 wxWindow *arg2 = (wxWindow *) NULL ;
32107 wxWindow *result;
32108 bool temp1 = false ;
32109 PyObject * obj0 = 0 ;
32110 PyObject * obj1 = 0 ;
32111 char *kwnames[] = {
32112 (char *) "name",(char *) "parent", NULL
32113 };
32114
32115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32116 {
32117 arg1 = wxString_in_helper(obj0);
32118 if (arg1 == NULL) SWIG_fail;
32119 temp1 = true;
32120 }
32121 if (obj1) {
32122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32123 if (SWIG_arg_fail(2)) SWIG_fail;
32124 }
32125 {
32126 if (!wxPyCheckForApp()) SWIG_fail;
32127 PyThreadState* __tstate = wxPyBeginAllowThreads();
32128 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32129
32130 wxPyEndAllowThreads(__tstate);
32131 if (PyErr_Occurred()) SWIG_fail;
32132 }
32133 {
32134 resultobj = wxPyMake_wxObject(result, 0);
32135 }
32136 {
32137 if (temp1)
32138 delete arg1;
32139 }
32140 return resultobj;
32141 fail:
32142 {
32143 if (temp1)
32144 delete arg1;
32145 }
32146 return NULL;
32147 }
32148
32149
32150 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32151 PyObject *resultobj;
32152 wxString *arg1 = 0 ;
32153 wxWindow *arg2 = (wxWindow *) NULL ;
32154 wxWindow *result;
32155 bool temp1 = false ;
32156 PyObject * obj0 = 0 ;
32157 PyObject * obj1 = 0 ;
32158 char *kwnames[] = {
32159 (char *) "label",(char *) "parent", NULL
32160 };
32161
32162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32163 {
32164 arg1 = wxString_in_helper(obj0);
32165 if (arg1 == NULL) SWIG_fail;
32166 temp1 = true;
32167 }
32168 if (obj1) {
32169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32170 if (SWIG_arg_fail(2)) SWIG_fail;
32171 }
32172 {
32173 if (!wxPyCheckForApp()) SWIG_fail;
32174 PyThreadState* __tstate = wxPyBeginAllowThreads();
32175 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32176
32177 wxPyEndAllowThreads(__tstate);
32178 if (PyErr_Occurred()) SWIG_fail;
32179 }
32180 {
32181 resultobj = wxPyMake_wxObject(result, 0);
32182 }
32183 {
32184 if (temp1)
32185 delete arg1;
32186 }
32187 return resultobj;
32188 fail:
32189 {
32190 if (temp1)
32191 delete arg1;
32192 }
32193 return NULL;
32194 }
32195
32196
32197 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32198 PyObject *resultobj;
32199 wxWindow *arg1 = (wxWindow *) 0 ;
32200 unsigned long arg2 ;
32201 wxWindow *result;
32202 PyObject * obj0 = 0 ;
32203 PyObject * obj1 = 0 ;
32204 char *kwnames[] = {
32205 (char *) "parent",(char *) "_hWnd", NULL
32206 };
32207
32208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32210 if (SWIG_arg_fail(1)) SWIG_fail;
32211 {
32212 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32213 if (SWIG_arg_fail(2)) SWIG_fail;
32214 }
32215 {
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32218
32219 wxPyEndAllowThreads(__tstate);
32220 if (PyErr_Occurred()) SWIG_fail;
32221 }
32222 {
32223 resultobj = wxPyMake_wxObject(result, 0);
32224 }
32225 return resultobj;
32226 fail:
32227 return NULL;
32228 }
32229
32230
32231 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32232 PyObject *resultobj;
32233 wxValidator *result;
32234 char *kwnames[] = {
32235 NULL
32236 };
32237
32238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32239 {
32240 PyThreadState* __tstate = wxPyBeginAllowThreads();
32241 result = (wxValidator *)new wxValidator();
32242
32243 wxPyEndAllowThreads(__tstate);
32244 if (PyErr_Occurred()) SWIG_fail;
32245 }
32246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32247 return resultobj;
32248 fail:
32249 return NULL;
32250 }
32251
32252
32253 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32254 PyObject *resultobj;
32255 wxValidator *arg1 = (wxValidator *) 0 ;
32256 wxValidator *result;
32257 PyObject * obj0 = 0 ;
32258 char *kwnames[] = {
32259 (char *) "self", NULL
32260 };
32261
32262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32264 if (SWIG_arg_fail(1)) SWIG_fail;
32265 {
32266 PyThreadState* __tstate = wxPyBeginAllowThreads();
32267 result = (wxValidator *)(arg1)->Clone();
32268
32269 wxPyEndAllowThreads(__tstate);
32270 if (PyErr_Occurred()) SWIG_fail;
32271 }
32272 {
32273 resultobj = wxPyMake_wxObject(result, 0);
32274 }
32275 return resultobj;
32276 fail:
32277 return NULL;
32278 }
32279
32280
32281 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32282 PyObject *resultobj;
32283 wxValidator *arg1 = (wxValidator *) 0 ;
32284 wxWindow *arg2 = (wxWindow *) 0 ;
32285 bool result;
32286 PyObject * obj0 = 0 ;
32287 PyObject * obj1 = 0 ;
32288 char *kwnames[] = {
32289 (char *) "self",(char *) "parent", NULL
32290 };
32291
32292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32294 if (SWIG_arg_fail(1)) SWIG_fail;
32295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32296 if (SWIG_arg_fail(2)) SWIG_fail;
32297 {
32298 PyThreadState* __tstate = wxPyBeginAllowThreads();
32299 result = (bool)(arg1)->Validate(arg2);
32300
32301 wxPyEndAllowThreads(__tstate);
32302 if (PyErr_Occurred()) SWIG_fail;
32303 }
32304 {
32305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32306 }
32307 return resultobj;
32308 fail:
32309 return NULL;
32310 }
32311
32312
32313 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32314 PyObject *resultobj;
32315 wxValidator *arg1 = (wxValidator *) 0 ;
32316 bool result;
32317 PyObject * obj0 = 0 ;
32318 char *kwnames[] = {
32319 (char *) "self", NULL
32320 };
32321
32322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32324 if (SWIG_arg_fail(1)) SWIG_fail;
32325 {
32326 PyThreadState* __tstate = wxPyBeginAllowThreads();
32327 result = (bool)(arg1)->TransferToWindow();
32328
32329 wxPyEndAllowThreads(__tstate);
32330 if (PyErr_Occurred()) SWIG_fail;
32331 }
32332 {
32333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32334 }
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32342 PyObject *resultobj;
32343 wxValidator *arg1 = (wxValidator *) 0 ;
32344 bool result;
32345 PyObject * obj0 = 0 ;
32346 char *kwnames[] = {
32347 (char *) "self", NULL
32348 };
32349
32350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32352 if (SWIG_arg_fail(1)) SWIG_fail;
32353 {
32354 PyThreadState* __tstate = wxPyBeginAllowThreads();
32355 result = (bool)(arg1)->TransferFromWindow();
32356
32357 wxPyEndAllowThreads(__tstate);
32358 if (PyErr_Occurred()) SWIG_fail;
32359 }
32360 {
32361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32362 }
32363 return resultobj;
32364 fail:
32365 return NULL;
32366 }
32367
32368
32369 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32370 PyObject *resultobj;
32371 wxValidator *arg1 = (wxValidator *) 0 ;
32372 wxWindow *result;
32373 PyObject * obj0 = 0 ;
32374 char *kwnames[] = {
32375 (char *) "self", NULL
32376 };
32377
32378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32380 if (SWIG_arg_fail(1)) SWIG_fail;
32381 {
32382 PyThreadState* __tstate = wxPyBeginAllowThreads();
32383 result = (wxWindow *)(arg1)->GetWindow();
32384
32385 wxPyEndAllowThreads(__tstate);
32386 if (PyErr_Occurred()) SWIG_fail;
32387 }
32388 {
32389 resultobj = wxPyMake_wxObject(result, 0);
32390 }
32391 return resultobj;
32392 fail:
32393 return NULL;
32394 }
32395
32396
32397 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32398 PyObject *resultobj;
32399 wxValidator *arg1 = (wxValidator *) 0 ;
32400 wxWindow *arg2 = (wxWindow *) 0 ;
32401 PyObject * obj0 = 0 ;
32402 PyObject * obj1 = 0 ;
32403 char *kwnames[] = {
32404 (char *) "self",(char *) "window", NULL
32405 };
32406
32407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32409 if (SWIG_arg_fail(1)) SWIG_fail;
32410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32411 if (SWIG_arg_fail(2)) SWIG_fail;
32412 {
32413 PyThreadState* __tstate = wxPyBeginAllowThreads();
32414 (arg1)->SetWindow(arg2);
32415
32416 wxPyEndAllowThreads(__tstate);
32417 if (PyErr_Occurred()) SWIG_fail;
32418 }
32419 Py_INCREF(Py_None); resultobj = Py_None;
32420 return resultobj;
32421 fail:
32422 return NULL;
32423 }
32424
32425
32426 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32427 PyObject *resultobj;
32428 bool result;
32429 char *kwnames[] = {
32430 NULL
32431 };
32432
32433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32434 {
32435 PyThreadState* __tstate = wxPyBeginAllowThreads();
32436 result = (bool)wxValidator::IsSilent();
32437
32438 wxPyEndAllowThreads(__tstate);
32439 if (PyErr_Occurred()) SWIG_fail;
32440 }
32441 {
32442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32443 }
32444 return resultobj;
32445 fail:
32446 return NULL;
32447 }
32448
32449
32450 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32451 PyObject *resultobj;
32452 int arg1 = (int) true ;
32453 PyObject * obj0 = 0 ;
32454 char *kwnames[] = {
32455 (char *) "doIt", NULL
32456 };
32457
32458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32459 if (obj0) {
32460 {
32461 arg1 = (int)(SWIG_As_int(obj0));
32462 if (SWIG_arg_fail(1)) SWIG_fail;
32463 }
32464 }
32465 {
32466 PyThreadState* __tstate = wxPyBeginAllowThreads();
32467 wxValidator::SetBellOnError(arg1);
32468
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 Py_INCREF(Py_None); resultobj = Py_None;
32473 return resultobj;
32474 fail:
32475 return NULL;
32476 }
32477
32478
32479 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32480 PyObject *obj;
32481 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32482 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32483 Py_INCREF(obj);
32484 return Py_BuildValue((char *)"");
32485 }
32486 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32487 PyObject *resultobj;
32488 wxPyValidator *result;
32489 char *kwnames[] = {
32490 NULL
32491 };
32492
32493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32494 {
32495 PyThreadState* __tstate = wxPyBeginAllowThreads();
32496 result = (wxPyValidator *)new wxPyValidator();
32497
32498 wxPyEndAllowThreads(__tstate);
32499 if (PyErr_Occurred()) SWIG_fail;
32500 }
32501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32502 return resultobj;
32503 fail:
32504 return NULL;
32505 }
32506
32507
32508 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32509 PyObject *resultobj;
32510 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32511 PyObject *arg2 = (PyObject *) 0 ;
32512 PyObject *arg3 = (PyObject *) 0 ;
32513 int arg4 = (int) true ;
32514 PyObject * obj0 = 0 ;
32515 PyObject * obj1 = 0 ;
32516 PyObject * obj2 = 0 ;
32517 PyObject * obj3 = 0 ;
32518 char *kwnames[] = {
32519 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32520 };
32521
32522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32524 if (SWIG_arg_fail(1)) SWIG_fail;
32525 arg2 = obj1;
32526 arg3 = obj2;
32527 if (obj3) {
32528 {
32529 arg4 = (int)(SWIG_As_int(obj3));
32530 if (SWIG_arg_fail(4)) SWIG_fail;
32531 }
32532 }
32533 {
32534 PyThreadState* __tstate = wxPyBeginAllowThreads();
32535 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32536
32537 wxPyEndAllowThreads(__tstate);
32538 if (PyErr_Occurred()) SWIG_fail;
32539 }
32540 Py_INCREF(Py_None); resultobj = Py_None;
32541 return resultobj;
32542 fail:
32543 return NULL;
32544 }
32545
32546
32547 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32548 PyObject *obj;
32549 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32550 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32551 Py_INCREF(obj);
32552 return Py_BuildValue((char *)"");
32553 }
32554 static int _wrap_DefaultValidator_set(PyObject *) {
32555 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32556 return 1;
32557 }
32558
32559
32560 static PyObject *_wrap_DefaultValidator_get(void) {
32561 PyObject *pyobj;
32562
32563 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32564 return pyobj;
32565 }
32566
32567
32568 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32569 PyObject *resultobj;
32570 wxString const &arg1_defvalue = wxPyEmptyString ;
32571 wxString *arg1 = (wxString *) &arg1_defvalue ;
32572 long arg2 = (long) 0 ;
32573 wxMenu *result;
32574 bool temp1 = false ;
32575 PyObject * obj0 = 0 ;
32576 PyObject * obj1 = 0 ;
32577 char *kwnames[] = {
32578 (char *) "title",(char *) "style", NULL
32579 };
32580
32581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32582 if (obj0) {
32583 {
32584 arg1 = wxString_in_helper(obj0);
32585 if (arg1 == NULL) SWIG_fail;
32586 temp1 = true;
32587 }
32588 }
32589 if (obj1) {
32590 {
32591 arg2 = (long)(SWIG_As_long(obj1));
32592 if (SWIG_arg_fail(2)) SWIG_fail;
32593 }
32594 }
32595 {
32596 if (!wxPyCheckForApp()) SWIG_fail;
32597 PyThreadState* __tstate = wxPyBeginAllowThreads();
32598 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32599
32600 wxPyEndAllowThreads(__tstate);
32601 if (PyErr_Occurred()) SWIG_fail;
32602 }
32603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32604 {
32605 if (temp1)
32606 delete arg1;
32607 }
32608 return resultobj;
32609 fail:
32610 {
32611 if (temp1)
32612 delete arg1;
32613 }
32614 return NULL;
32615 }
32616
32617
32618 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32619 PyObject *resultobj;
32620 wxMenu *arg1 = (wxMenu *) 0 ;
32621 int arg2 ;
32622 wxString *arg3 = 0 ;
32623 wxString const &arg4_defvalue = wxPyEmptyString ;
32624 wxString *arg4 = (wxString *) &arg4_defvalue ;
32625 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32626 wxMenuItem *result;
32627 bool temp3 = false ;
32628 bool temp4 = false ;
32629 PyObject * obj0 = 0 ;
32630 PyObject * obj1 = 0 ;
32631 PyObject * obj2 = 0 ;
32632 PyObject * obj3 = 0 ;
32633 PyObject * obj4 = 0 ;
32634 char *kwnames[] = {
32635 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32636 };
32637
32638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32640 if (SWIG_arg_fail(1)) SWIG_fail;
32641 {
32642 arg2 = (int)(SWIG_As_int(obj1));
32643 if (SWIG_arg_fail(2)) SWIG_fail;
32644 }
32645 {
32646 arg3 = wxString_in_helper(obj2);
32647 if (arg3 == NULL) SWIG_fail;
32648 temp3 = true;
32649 }
32650 if (obj3) {
32651 {
32652 arg4 = wxString_in_helper(obj3);
32653 if (arg4 == NULL) SWIG_fail;
32654 temp4 = true;
32655 }
32656 }
32657 if (obj4) {
32658 {
32659 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32660 if (SWIG_arg_fail(5)) SWIG_fail;
32661 }
32662 }
32663 {
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32666
32667 wxPyEndAllowThreads(__tstate);
32668 if (PyErr_Occurred()) SWIG_fail;
32669 }
32670 {
32671 resultobj = wxPyMake_wxObject(result, 0);
32672 }
32673 {
32674 if (temp3)
32675 delete arg3;
32676 }
32677 {
32678 if (temp4)
32679 delete arg4;
32680 }
32681 return resultobj;
32682 fail:
32683 {
32684 if (temp3)
32685 delete arg3;
32686 }
32687 {
32688 if (temp4)
32689 delete arg4;
32690 }
32691 return NULL;
32692 }
32693
32694
32695 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32696 PyObject *resultobj;
32697 wxMenu *arg1 = (wxMenu *) 0 ;
32698 wxMenuItem *result;
32699 PyObject * obj0 = 0 ;
32700 char *kwnames[] = {
32701 (char *) "self", NULL
32702 };
32703
32704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32706 if (SWIG_arg_fail(1)) SWIG_fail;
32707 {
32708 PyThreadState* __tstate = wxPyBeginAllowThreads();
32709 result = (wxMenuItem *)(arg1)->AppendSeparator();
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_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32724 PyObject *resultobj;
32725 wxMenu *arg1 = (wxMenu *) 0 ;
32726 int arg2 ;
32727 wxString *arg3 = 0 ;
32728 wxString const &arg4_defvalue = wxPyEmptyString ;
32729 wxString *arg4 = (wxString *) &arg4_defvalue ;
32730 wxMenuItem *result;
32731 bool temp3 = false ;
32732 bool temp4 = false ;
32733 PyObject * obj0 = 0 ;
32734 PyObject * obj1 = 0 ;
32735 PyObject * obj2 = 0 ;
32736 PyObject * obj3 = 0 ;
32737 char *kwnames[] = {
32738 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32739 };
32740
32741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32743 if (SWIG_arg_fail(1)) SWIG_fail;
32744 {
32745 arg2 = (int)(SWIG_As_int(obj1));
32746 if (SWIG_arg_fail(2)) SWIG_fail;
32747 }
32748 {
32749 arg3 = wxString_in_helper(obj2);
32750 if (arg3 == NULL) SWIG_fail;
32751 temp3 = true;
32752 }
32753 if (obj3) {
32754 {
32755 arg4 = wxString_in_helper(obj3);
32756 if (arg4 == NULL) SWIG_fail;
32757 temp4 = true;
32758 }
32759 }
32760 {
32761 PyThreadState* __tstate = wxPyBeginAllowThreads();
32762 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32763
32764 wxPyEndAllowThreads(__tstate);
32765 if (PyErr_Occurred()) SWIG_fail;
32766 }
32767 {
32768 resultobj = wxPyMake_wxObject(result, 0);
32769 }
32770 {
32771 if (temp3)
32772 delete arg3;
32773 }
32774 {
32775 if (temp4)
32776 delete arg4;
32777 }
32778 return resultobj;
32779 fail:
32780 {
32781 if (temp3)
32782 delete arg3;
32783 }
32784 {
32785 if (temp4)
32786 delete arg4;
32787 }
32788 return NULL;
32789 }
32790
32791
32792 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32793 PyObject *resultobj;
32794 wxMenu *arg1 = (wxMenu *) 0 ;
32795 int arg2 ;
32796 wxString *arg3 = 0 ;
32797 wxString const &arg4_defvalue = wxPyEmptyString ;
32798 wxString *arg4 = (wxString *) &arg4_defvalue ;
32799 wxMenuItem *result;
32800 bool temp3 = false ;
32801 bool temp4 = false ;
32802 PyObject * obj0 = 0 ;
32803 PyObject * obj1 = 0 ;
32804 PyObject * obj2 = 0 ;
32805 PyObject * obj3 = 0 ;
32806 char *kwnames[] = {
32807 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32808 };
32809
32810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32812 if (SWIG_arg_fail(1)) SWIG_fail;
32813 {
32814 arg2 = (int)(SWIG_As_int(obj1));
32815 if (SWIG_arg_fail(2)) SWIG_fail;
32816 }
32817 {
32818 arg3 = wxString_in_helper(obj2);
32819 if (arg3 == NULL) SWIG_fail;
32820 temp3 = true;
32821 }
32822 if (obj3) {
32823 {
32824 arg4 = wxString_in_helper(obj3);
32825 if (arg4 == NULL) SWIG_fail;
32826 temp4 = true;
32827 }
32828 }
32829 {
32830 PyThreadState* __tstate = wxPyBeginAllowThreads();
32831 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32832
32833 wxPyEndAllowThreads(__tstate);
32834 if (PyErr_Occurred()) SWIG_fail;
32835 }
32836 {
32837 resultobj = wxPyMake_wxObject(result, 0);
32838 }
32839 {
32840 if (temp3)
32841 delete arg3;
32842 }
32843 {
32844 if (temp4)
32845 delete arg4;
32846 }
32847 return resultobj;
32848 fail:
32849 {
32850 if (temp3)
32851 delete arg3;
32852 }
32853 {
32854 if (temp4)
32855 delete arg4;
32856 }
32857 return NULL;
32858 }
32859
32860
32861 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32862 PyObject *resultobj;
32863 wxMenu *arg1 = (wxMenu *) 0 ;
32864 int arg2 ;
32865 wxString *arg3 = 0 ;
32866 wxMenu *arg4 = (wxMenu *) 0 ;
32867 wxString const &arg5_defvalue = wxPyEmptyString ;
32868 wxString *arg5 = (wxString *) &arg5_defvalue ;
32869 wxMenuItem *result;
32870 bool temp3 = false ;
32871 bool temp5 = false ;
32872 PyObject * obj0 = 0 ;
32873 PyObject * obj1 = 0 ;
32874 PyObject * obj2 = 0 ;
32875 PyObject * obj3 = 0 ;
32876 PyObject * obj4 = 0 ;
32877 char *kwnames[] = {
32878 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32879 };
32880
32881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32883 if (SWIG_arg_fail(1)) SWIG_fail;
32884 {
32885 arg2 = (int)(SWIG_As_int(obj1));
32886 if (SWIG_arg_fail(2)) SWIG_fail;
32887 }
32888 {
32889 arg3 = wxString_in_helper(obj2);
32890 if (arg3 == NULL) SWIG_fail;
32891 temp3 = true;
32892 }
32893 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32894 if (SWIG_arg_fail(4)) SWIG_fail;
32895 if (obj4) {
32896 {
32897 arg5 = wxString_in_helper(obj4);
32898 if (arg5 == NULL) SWIG_fail;
32899 temp5 = true;
32900 }
32901 }
32902 {
32903 PyThreadState* __tstate = wxPyBeginAllowThreads();
32904 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32905
32906 wxPyEndAllowThreads(__tstate);
32907 if (PyErr_Occurred()) SWIG_fail;
32908 }
32909 {
32910 resultobj = wxPyMake_wxObject(result, 0);
32911 }
32912 {
32913 if (temp3)
32914 delete arg3;
32915 }
32916 {
32917 if (temp5)
32918 delete arg5;
32919 }
32920 return resultobj;
32921 fail:
32922 {
32923 if (temp3)
32924 delete arg3;
32925 }
32926 {
32927 if (temp5)
32928 delete arg5;
32929 }
32930 return NULL;
32931 }
32932
32933
32934 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32935 PyObject *resultobj;
32936 wxMenu *arg1 = (wxMenu *) 0 ;
32937 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32938 wxMenuItem *result;
32939 PyObject * obj0 = 0 ;
32940 PyObject * obj1 = 0 ;
32941 char *kwnames[] = {
32942 (char *) "self",(char *) "item", NULL
32943 };
32944
32945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32947 if (SWIG_arg_fail(1)) SWIG_fail;
32948 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32949 if (SWIG_arg_fail(2)) SWIG_fail;
32950 {
32951 PyThreadState* __tstate = wxPyBeginAllowThreads();
32952 result = (wxMenuItem *)(arg1)->Append(arg2);
32953
32954 wxPyEndAllowThreads(__tstate);
32955 if (PyErr_Occurred()) SWIG_fail;
32956 }
32957 {
32958 resultobj = wxPyMake_wxObject(result, 0);
32959 }
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32967 PyObject *resultobj;
32968 wxMenu *arg1 = (wxMenu *) 0 ;
32969 PyObject * obj0 = 0 ;
32970 char *kwnames[] = {
32971 (char *) "self", NULL
32972 };
32973
32974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32976 if (SWIG_arg_fail(1)) SWIG_fail;
32977 {
32978 PyThreadState* __tstate = wxPyBeginAllowThreads();
32979 (arg1)->Break();
32980
32981 wxPyEndAllowThreads(__tstate);
32982 if (PyErr_Occurred()) SWIG_fail;
32983 }
32984 Py_INCREF(Py_None); resultobj = Py_None;
32985 return resultobj;
32986 fail:
32987 return NULL;
32988 }
32989
32990
32991 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32992 PyObject *resultobj;
32993 wxMenu *arg1 = (wxMenu *) 0 ;
32994 size_t arg2 ;
32995 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32996 wxMenuItem *result;
32997 PyObject * obj0 = 0 ;
32998 PyObject * obj1 = 0 ;
32999 PyObject * obj2 = 0 ;
33000 char *kwnames[] = {
33001 (char *) "self",(char *) "pos",(char *) "item", NULL
33002 };
33003
33004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) 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 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33009 if (SWIG_arg_fail(2)) SWIG_fail;
33010 }
33011 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33012 if (SWIG_arg_fail(3)) SWIG_fail;
33013 {
33014 PyThreadState* __tstate = wxPyBeginAllowThreads();
33015 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33016
33017 wxPyEndAllowThreads(__tstate);
33018 if (PyErr_Occurred()) SWIG_fail;
33019 }
33020 {
33021 resultobj = wxPyMake_wxObject(result, 0);
33022 }
33023 return resultobj;
33024 fail:
33025 return NULL;
33026 }
33027
33028
33029 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33030 PyObject *resultobj;
33031 wxMenu *arg1 = (wxMenu *) 0 ;
33032 size_t arg2 ;
33033 int arg3 ;
33034 wxString *arg4 = 0 ;
33035 wxString const &arg5_defvalue = wxPyEmptyString ;
33036 wxString *arg5 = (wxString *) &arg5_defvalue ;
33037 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33038 wxMenuItem *result;
33039 bool temp4 = false ;
33040 bool temp5 = false ;
33041 PyObject * obj0 = 0 ;
33042 PyObject * obj1 = 0 ;
33043 PyObject * obj2 = 0 ;
33044 PyObject * obj3 = 0 ;
33045 PyObject * obj4 = 0 ;
33046 PyObject * obj5 = 0 ;
33047 char *kwnames[] = {
33048 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33049 };
33050
33051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33053 if (SWIG_arg_fail(1)) SWIG_fail;
33054 {
33055 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33056 if (SWIG_arg_fail(2)) SWIG_fail;
33057 }
33058 {
33059 arg3 = (int)(SWIG_As_int(obj2));
33060 if (SWIG_arg_fail(3)) SWIG_fail;
33061 }
33062 {
33063 arg4 = wxString_in_helper(obj3);
33064 if (arg4 == NULL) SWIG_fail;
33065 temp4 = true;
33066 }
33067 if (obj4) {
33068 {
33069 arg5 = wxString_in_helper(obj4);
33070 if (arg5 == NULL) SWIG_fail;
33071 temp5 = true;
33072 }
33073 }
33074 if (obj5) {
33075 {
33076 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33077 if (SWIG_arg_fail(6)) SWIG_fail;
33078 }
33079 }
33080 {
33081 PyThreadState* __tstate = wxPyBeginAllowThreads();
33082 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33083
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 {
33088 resultobj = wxPyMake_wxObject(result, 0);
33089 }
33090 {
33091 if (temp4)
33092 delete arg4;
33093 }
33094 {
33095 if (temp5)
33096 delete arg5;
33097 }
33098 return resultobj;
33099 fail:
33100 {
33101 if (temp4)
33102 delete arg4;
33103 }
33104 {
33105 if (temp5)
33106 delete arg5;
33107 }
33108 return NULL;
33109 }
33110
33111
33112 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33113 PyObject *resultobj;
33114 wxMenu *arg1 = (wxMenu *) 0 ;
33115 size_t arg2 ;
33116 wxMenuItem *result;
33117 PyObject * obj0 = 0 ;
33118 PyObject * obj1 = 0 ;
33119 char *kwnames[] = {
33120 (char *) "self",(char *) "pos", NULL
33121 };
33122
33123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33125 if (SWIG_arg_fail(1)) SWIG_fail;
33126 {
33127 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33128 if (SWIG_arg_fail(2)) SWIG_fail;
33129 }
33130 {
33131 PyThreadState* __tstate = wxPyBeginAllowThreads();
33132 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33133
33134 wxPyEndAllowThreads(__tstate);
33135 if (PyErr_Occurred()) SWIG_fail;
33136 }
33137 {
33138 resultobj = wxPyMake_wxObject(result, 0);
33139 }
33140 return resultobj;
33141 fail:
33142 return NULL;
33143 }
33144
33145
33146 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33147 PyObject *resultobj;
33148 wxMenu *arg1 = (wxMenu *) 0 ;
33149 size_t arg2 ;
33150 int arg3 ;
33151 wxString *arg4 = 0 ;
33152 wxString const &arg5_defvalue = wxPyEmptyString ;
33153 wxString *arg5 = (wxString *) &arg5_defvalue ;
33154 wxMenuItem *result;
33155 bool temp4 = false ;
33156 bool temp5 = false ;
33157 PyObject * obj0 = 0 ;
33158 PyObject * obj1 = 0 ;
33159 PyObject * obj2 = 0 ;
33160 PyObject * obj3 = 0 ;
33161 PyObject * obj4 = 0 ;
33162 char *kwnames[] = {
33163 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33164 };
33165
33166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33168 if (SWIG_arg_fail(1)) SWIG_fail;
33169 {
33170 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33171 if (SWIG_arg_fail(2)) SWIG_fail;
33172 }
33173 {
33174 arg3 = (int)(SWIG_As_int(obj2));
33175 if (SWIG_arg_fail(3)) SWIG_fail;
33176 }
33177 {
33178 arg4 = wxString_in_helper(obj3);
33179 if (arg4 == NULL) SWIG_fail;
33180 temp4 = true;
33181 }
33182 if (obj4) {
33183 {
33184 arg5 = wxString_in_helper(obj4);
33185 if (arg5 == NULL) SWIG_fail;
33186 temp5 = true;
33187 }
33188 }
33189 {
33190 PyThreadState* __tstate = wxPyBeginAllowThreads();
33191 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33192
33193 wxPyEndAllowThreads(__tstate);
33194 if (PyErr_Occurred()) SWIG_fail;
33195 }
33196 {
33197 resultobj = wxPyMake_wxObject(result, 0);
33198 }
33199 {
33200 if (temp4)
33201 delete arg4;
33202 }
33203 {
33204 if (temp5)
33205 delete arg5;
33206 }
33207 return resultobj;
33208 fail:
33209 {
33210 if (temp4)
33211 delete arg4;
33212 }
33213 {
33214 if (temp5)
33215 delete arg5;
33216 }
33217 return NULL;
33218 }
33219
33220
33221 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33222 PyObject *resultobj;
33223 wxMenu *arg1 = (wxMenu *) 0 ;
33224 size_t arg2 ;
33225 int arg3 ;
33226 wxString *arg4 = 0 ;
33227 wxString const &arg5_defvalue = wxPyEmptyString ;
33228 wxString *arg5 = (wxString *) &arg5_defvalue ;
33229 wxMenuItem *result;
33230 bool temp4 = false ;
33231 bool temp5 = false ;
33232 PyObject * obj0 = 0 ;
33233 PyObject * obj1 = 0 ;
33234 PyObject * obj2 = 0 ;
33235 PyObject * obj3 = 0 ;
33236 PyObject * obj4 = 0 ;
33237 char *kwnames[] = {
33238 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33239 };
33240
33241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33243 if (SWIG_arg_fail(1)) SWIG_fail;
33244 {
33245 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33246 if (SWIG_arg_fail(2)) SWIG_fail;
33247 }
33248 {
33249 arg3 = (int)(SWIG_As_int(obj2));
33250 if (SWIG_arg_fail(3)) SWIG_fail;
33251 }
33252 {
33253 arg4 = wxString_in_helper(obj3);
33254 if (arg4 == NULL) SWIG_fail;
33255 temp4 = true;
33256 }
33257 if (obj4) {
33258 {
33259 arg5 = wxString_in_helper(obj4);
33260 if (arg5 == NULL) SWIG_fail;
33261 temp5 = true;
33262 }
33263 }
33264 {
33265 PyThreadState* __tstate = wxPyBeginAllowThreads();
33266 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33267
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 {
33272 resultobj = wxPyMake_wxObject(result, 0);
33273 }
33274 {
33275 if (temp4)
33276 delete arg4;
33277 }
33278 {
33279 if (temp5)
33280 delete arg5;
33281 }
33282 return resultobj;
33283 fail:
33284 {
33285 if (temp4)
33286 delete arg4;
33287 }
33288 {
33289 if (temp5)
33290 delete arg5;
33291 }
33292 return NULL;
33293 }
33294
33295
33296 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33297 PyObject *resultobj;
33298 wxMenu *arg1 = (wxMenu *) 0 ;
33299 size_t arg2 ;
33300 int arg3 ;
33301 wxString *arg4 = 0 ;
33302 wxMenu *arg5 = (wxMenu *) 0 ;
33303 wxString const &arg6_defvalue = wxPyEmptyString ;
33304 wxString *arg6 = (wxString *) &arg6_defvalue ;
33305 wxMenuItem *result;
33306 bool temp4 = false ;
33307 bool temp6 = false ;
33308 PyObject * obj0 = 0 ;
33309 PyObject * obj1 = 0 ;
33310 PyObject * obj2 = 0 ;
33311 PyObject * obj3 = 0 ;
33312 PyObject * obj4 = 0 ;
33313 PyObject * obj5 = 0 ;
33314 char *kwnames[] = {
33315 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33316 };
33317
33318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33320 if (SWIG_arg_fail(1)) SWIG_fail;
33321 {
33322 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33323 if (SWIG_arg_fail(2)) SWIG_fail;
33324 }
33325 {
33326 arg3 = (int)(SWIG_As_int(obj2));
33327 if (SWIG_arg_fail(3)) SWIG_fail;
33328 }
33329 {
33330 arg4 = wxString_in_helper(obj3);
33331 if (arg4 == NULL) SWIG_fail;
33332 temp4 = true;
33333 }
33334 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33335 if (SWIG_arg_fail(5)) SWIG_fail;
33336 if (obj5) {
33337 {
33338 arg6 = wxString_in_helper(obj5);
33339 if (arg6 == NULL) SWIG_fail;
33340 temp6 = true;
33341 }
33342 }
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33346
33347 wxPyEndAllowThreads(__tstate);
33348 if (PyErr_Occurred()) SWIG_fail;
33349 }
33350 {
33351 resultobj = wxPyMake_wxObject(result, 0);
33352 }
33353 {
33354 if (temp4)
33355 delete arg4;
33356 }
33357 {
33358 if (temp6)
33359 delete arg6;
33360 }
33361 return resultobj;
33362 fail:
33363 {
33364 if (temp4)
33365 delete arg4;
33366 }
33367 {
33368 if (temp6)
33369 delete arg6;
33370 }
33371 return NULL;
33372 }
33373
33374
33375 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33376 PyObject *resultobj;
33377 wxMenu *arg1 = (wxMenu *) 0 ;
33378 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33379 wxMenuItem *result;
33380 PyObject * obj0 = 0 ;
33381 PyObject * obj1 = 0 ;
33382 char *kwnames[] = {
33383 (char *) "self",(char *) "item", NULL
33384 };
33385
33386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33388 if (SWIG_arg_fail(1)) SWIG_fail;
33389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33390 if (SWIG_arg_fail(2)) SWIG_fail;
33391 {
33392 PyThreadState* __tstate = wxPyBeginAllowThreads();
33393 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33394
33395 wxPyEndAllowThreads(__tstate);
33396 if (PyErr_Occurred()) SWIG_fail;
33397 }
33398 {
33399 resultobj = wxPyMake_wxObject(result, 0);
33400 }
33401 return resultobj;
33402 fail:
33403 return NULL;
33404 }
33405
33406
33407 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33408 PyObject *resultobj;
33409 wxMenu *arg1 = (wxMenu *) 0 ;
33410 int arg2 ;
33411 wxString *arg3 = 0 ;
33412 wxString const &arg4_defvalue = wxPyEmptyString ;
33413 wxString *arg4 = (wxString *) &arg4_defvalue ;
33414 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33415 wxMenuItem *result;
33416 bool temp3 = false ;
33417 bool temp4 = false ;
33418 PyObject * obj0 = 0 ;
33419 PyObject * obj1 = 0 ;
33420 PyObject * obj2 = 0 ;
33421 PyObject * obj3 = 0 ;
33422 PyObject * obj4 = 0 ;
33423 char *kwnames[] = {
33424 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33425 };
33426
33427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33429 if (SWIG_arg_fail(1)) SWIG_fail;
33430 {
33431 arg2 = (int)(SWIG_As_int(obj1));
33432 if (SWIG_arg_fail(2)) SWIG_fail;
33433 }
33434 {
33435 arg3 = wxString_in_helper(obj2);
33436 if (arg3 == NULL) SWIG_fail;
33437 temp3 = true;
33438 }
33439 if (obj3) {
33440 {
33441 arg4 = wxString_in_helper(obj3);
33442 if (arg4 == NULL) SWIG_fail;
33443 temp4 = true;
33444 }
33445 }
33446 if (obj4) {
33447 {
33448 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33449 if (SWIG_arg_fail(5)) SWIG_fail;
33450 }
33451 }
33452 {
33453 PyThreadState* __tstate = wxPyBeginAllowThreads();
33454 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33455
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 {
33460 resultobj = wxPyMake_wxObject(result, 0);
33461 }
33462 {
33463 if (temp3)
33464 delete arg3;
33465 }
33466 {
33467 if (temp4)
33468 delete arg4;
33469 }
33470 return resultobj;
33471 fail:
33472 {
33473 if (temp3)
33474 delete arg3;
33475 }
33476 {
33477 if (temp4)
33478 delete arg4;
33479 }
33480 return NULL;
33481 }
33482
33483
33484 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33485 PyObject *resultobj;
33486 wxMenu *arg1 = (wxMenu *) 0 ;
33487 wxMenuItem *result;
33488 PyObject * obj0 = 0 ;
33489 char *kwnames[] = {
33490 (char *) "self", NULL
33491 };
33492
33493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33495 if (SWIG_arg_fail(1)) SWIG_fail;
33496 {
33497 PyThreadState* __tstate = wxPyBeginAllowThreads();
33498 result = (wxMenuItem *)(arg1)->PrependSeparator();
33499
33500 wxPyEndAllowThreads(__tstate);
33501 if (PyErr_Occurred()) SWIG_fail;
33502 }
33503 {
33504 resultobj = wxPyMake_wxObject(result, 0);
33505 }
33506 return resultobj;
33507 fail:
33508 return NULL;
33509 }
33510
33511
33512 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33513 PyObject *resultobj;
33514 wxMenu *arg1 = (wxMenu *) 0 ;
33515 int arg2 ;
33516 wxString *arg3 = 0 ;
33517 wxString const &arg4_defvalue = wxPyEmptyString ;
33518 wxString *arg4 = (wxString *) &arg4_defvalue ;
33519 wxMenuItem *result;
33520 bool temp3 = false ;
33521 bool temp4 = false ;
33522 PyObject * obj0 = 0 ;
33523 PyObject * obj1 = 0 ;
33524 PyObject * obj2 = 0 ;
33525 PyObject * obj3 = 0 ;
33526 char *kwnames[] = {
33527 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33528 };
33529
33530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33532 if (SWIG_arg_fail(1)) SWIG_fail;
33533 {
33534 arg2 = (int)(SWIG_As_int(obj1));
33535 if (SWIG_arg_fail(2)) SWIG_fail;
33536 }
33537 {
33538 arg3 = wxString_in_helper(obj2);
33539 if (arg3 == NULL) SWIG_fail;
33540 temp3 = true;
33541 }
33542 if (obj3) {
33543 {
33544 arg4 = wxString_in_helper(obj3);
33545 if (arg4 == NULL) SWIG_fail;
33546 temp4 = true;
33547 }
33548 }
33549 {
33550 PyThreadState* __tstate = wxPyBeginAllowThreads();
33551 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33552
33553 wxPyEndAllowThreads(__tstate);
33554 if (PyErr_Occurred()) SWIG_fail;
33555 }
33556 {
33557 resultobj = wxPyMake_wxObject(result, 0);
33558 }
33559 {
33560 if (temp3)
33561 delete arg3;
33562 }
33563 {
33564 if (temp4)
33565 delete arg4;
33566 }
33567 return resultobj;
33568 fail:
33569 {
33570 if (temp3)
33571 delete arg3;
33572 }
33573 {
33574 if (temp4)
33575 delete arg4;
33576 }
33577 return NULL;
33578 }
33579
33580
33581 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33582 PyObject *resultobj;
33583 wxMenu *arg1 = (wxMenu *) 0 ;
33584 int arg2 ;
33585 wxString *arg3 = 0 ;
33586 wxString const &arg4_defvalue = wxPyEmptyString ;
33587 wxString *arg4 = (wxString *) &arg4_defvalue ;
33588 wxMenuItem *result;
33589 bool temp3 = false ;
33590 bool temp4 = false ;
33591 PyObject * obj0 = 0 ;
33592 PyObject * obj1 = 0 ;
33593 PyObject * obj2 = 0 ;
33594 PyObject * obj3 = 0 ;
33595 char *kwnames[] = {
33596 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33597 };
33598
33599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33601 if (SWIG_arg_fail(1)) SWIG_fail;
33602 {
33603 arg2 = (int)(SWIG_As_int(obj1));
33604 if (SWIG_arg_fail(2)) SWIG_fail;
33605 }
33606 {
33607 arg3 = wxString_in_helper(obj2);
33608 if (arg3 == NULL) SWIG_fail;
33609 temp3 = true;
33610 }
33611 if (obj3) {
33612 {
33613 arg4 = wxString_in_helper(obj3);
33614 if (arg4 == NULL) SWIG_fail;
33615 temp4 = true;
33616 }
33617 }
33618 {
33619 PyThreadState* __tstate = wxPyBeginAllowThreads();
33620 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33621
33622 wxPyEndAllowThreads(__tstate);
33623 if (PyErr_Occurred()) SWIG_fail;
33624 }
33625 {
33626 resultobj = wxPyMake_wxObject(result, 0);
33627 }
33628 {
33629 if (temp3)
33630 delete arg3;
33631 }
33632 {
33633 if (temp4)
33634 delete arg4;
33635 }
33636 return resultobj;
33637 fail:
33638 {
33639 if (temp3)
33640 delete arg3;
33641 }
33642 {
33643 if (temp4)
33644 delete arg4;
33645 }
33646 return NULL;
33647 }
33648
33649
33650 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33651 PyObject *resultobj;
33652 wxMenu *arg1 = (wxMenu *) 0 ;
33653 int arg2 ;
33654 wxString *arg3 = 0 ;
33655 wxMenu *arg4 = (wxMenu *) 0 ;
33656 wxString const &arg5_defvalue = wxPyEmptyString ;
33657 wxString *arg5 = (wxString *) &arg5_defvalue ;
33658 wxMenuItem *result;
33659 bool temp3 = false ;
33660 bool temp5 = false ;
33661 PyObject * obj0 = 0 ;
33662 PyObject * obj1 = 0 ;
33663 PyObject * obj2 = 0 ;
33664 PyObject * obj3 = 0 ;
33665 PyObject * obj4 = 0 ;
33666 char *kwnames[] = {
33667 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33668 };
33669
33670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33672 if (SWIG_arg_fail(1)) SWIG_fail;
33673 {
33674 arg2 = (int)(SWIG_As_int(obj1));
33675 if (SWIG_arg_fail(2)) SWIG_fail;
33676 }
33677 {
33678 arg3 = wxString_in_helper(obj2);
33679 if (arg3 == NULL) SWIG_fail;
33680 temp3 = true;
33681 }
33682 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33683 if (SWIG_arg_fail(4)) SWIG_fail;
33684 if (obj4) {
33685 {
33686 arg5 = wxString_in_helper(obj4);
33687 if (arg5 == NULL) SWIG_fail;
33688 temp5 = true;
33689 }
33690 }
33691 {
33692 PyThreadState* __tstate = wxPyBeginAllowThreads();
33693 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33694
33695 wxPyEndAllowThreads(__tstate);
33696 if (PyErr_Occurred()) SWIG_fail;
33697 }
33698 {
33699 resultobj = wxPyMake_wxObject(result, 0);
33700 }
33701 {
33702 if (temp3)
33703 delete arg3;
33704 }
33705 {
33706 if (temp5)
33707 delete arg5;
33708 }
33709 return resultobj;
33710 fail:
33711 {
33712 if (temp3)
33713 delete arg3;
33714 }
33715 {
33716 if (temp5)
33717 delete arg5;
33718 }
33719 return NULL;
33720 }
33721
33722
33723 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33724 PyObject *resultobj;
33725 wxMenu *arg1 = (wxMenu *) 0 ;
33726 int arg2 ;
33727 wxMenuItem *result;
33728 PyObject * obj0 = 0 ;
33729 PyObject * obj1 = 0 ;
33730 char *kwnames[] = {
33731 (char *) "self",(char *) "id", NULL
33732 };
33733
33734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33736 if (SWIG_arg_fail(1)) SWIG_fail;
33737 {
33738 arg2 = (int)(SWIG_As_int(obj1));
33739 if (SWIG_arg_fail(2)) SWIG_fail;
33740 }
33741 {
33742 PyThreadState* __tstate = wxPyBeginAllowThreads();
33743 result = (wxMenuItem *)(arg1)->Remove(arg2);
33744
33745 wxPyEndAllowThreads(__tstate);
33746 if (PyErr_Occurred()) SWIG_fail;
33747 }
33748 {
33749 resultobj = wxPyMake_wxObject(result, 0);
33750 }
33751 return resultobj;
33752 fail:
33753 return NULL;
33754 }
33755
33756
33757 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33758 PyObject *resultobj;
33759 wxMenu *arg1 = (wxMenu *) 0 ;
33760 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33761 wxMenuItem *result;
33762 PyObject * obj0 = 0 ;
33763 PyObject * obj1 = 0 ;
33764 char *kwnames[] = {
33765 (char *) "self",(char *) "item", NULL
33766 };
33767
33768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33770 if (SWIG_arg_fail(1)) SWIG_fail;
33771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33772 if (SWIG_arg_fail(2)) SWIG_fail;
33773 {
33774 PyThreadState* __tstate = wxPyBeginAllowThreads();
33775 result = (wxMenuItem *)(arg1)->Remove(arg2);
33776
33777 wxPyEndAllowThreads(__tstate);
33778 if (PyErr_Occurred()) SWIG_fail;
33779 }
33780 {
33781 resultobj = wxPyMake_wxObject(result, 0);
33782 }
33783 return resultobj;
33784 fail:
33785 return NULL;
33786 }
33787
33788
33789 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33790 PyObject *resultobj;
33791 wxMenu *arg1 = (wxMenu *) 0 ;
33792 int arg2 ;
33793 bool result;
33794 PyObject * obj0 = 0 ;
33795 PyObject * obj1 = 0 ;
33796 char *kwnames[] = {
33797 (char *) "self",(char *) "id", NULL
33798 };
33799
33800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33802 if (SWIG_arg_fail(1)) SWIG_fail;
33803 {
33804 arg2 = (int)(SWIG_As_int(obj1));
33805 if (SWIG_arg_fail(2)) SWIG_fail;
33806 }
33807 {
33808 PyThreadState* __tstate = wxPyBeginAllowThreads();
33809 result = (bool)(arg1)->Delete(arg2);
33810
33811 wxPyEndAllowThreads(__tstate);
33812 if (PyErr_Occurred()) SWIG_fail;
33813 }
33814 {
33815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33816 }
33817 return resultobj;
33818 fail:
33819 return NULL;
33820 }
33821
33822
33823 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33824 PyObject *resultobj;
33825 wxMenu *arg1 = (wxMenu *) 0 ;
33826 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33827 bool result;
33828 PyObject * obj0 = 0 ;
33829 PyObject * obj1 = 0 ;
33830 char *kwnames[] = {
33831 (char *) "self",(char *) "item", NULL
33832 };
33833
33834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33836 if (SWIG_arg_fail(1)) SWIG_fail;
33837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33838 if (SWIG_arg_fail(2)) SWIG_fail;
33839 {
33840 PyThreadState* __tstate = wxPyBeginAllowThreads();
33841 result = (bool)(arg1)->Delete(arg2);
33842
33843 wxPyEndAllowThreads(__tstate);
33844 if (PyErr_Occurred()) SWIG_fail;
33845 }
33846 {
33847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33848 }
33849 return resultobj;
33850 fail:
33851 return NULL;
33852 }
33853
33854
33855 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33856 PyObject *resultobj;
33857 wxMenu *arg1 = (wxMenu *) 0 ;
33858 PyObject * obj0 = 0 ;
33859 char *kwnames[] = {
33860 (char *) "self", NULL
33861 };
33862
33863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33865 if (SWIG_arg_fail(1)) SWIG_fail;
33866 {
33867 PyThreadState* __tstate = wxPyBeginAllowThreads();
33868 wxMenu_Destroy(arg1);
33869
33870 wxPyEndAllowThreads(__tstate);
33871 if (PyErr_Occurred()) SWIG_fail;
33872 }
33873 Py_INCREF(Py_None); resultobj = Py_None;
33874 return resultobj;
33875 fail:
33876 return NULL;
33877 }
33878
33879
33880 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33881 PyObject *resultobj;
33882 wxMenu *arg1 = (wxMenu *) 0 ;
33883 int arg2 ;
33884 bool result;
33885 PyObject * obj0 = 0 ;
33886 PyObject * obj1 = 0 ;
33887 char *kwnames[] = {
33888 (char *) "self",(char *) "id", NULL
33889 };
33890
33891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33893 if (SWIG_arg_fail(1)) SWIG_fail;
33894 {
33895 arg2 = (int)(SWIG_As_int(obj1));
33896 if (SWIG_arg_fail(2)) SWIG_fail;
33897 }
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (bool)(arg1)->Destroy(arg2);
33901
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 {
33906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33907 }
33908 return resultobj;
33909 fail:
33910 return NULL;
33911 }
33912
33913
33914 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33915 PyObject *resultobj;
33916 wxMenu *arg1 = (wxMenu *) 0 ;
33917 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33918 bool result;
33919 PyObject * obj0 = 0 ;
33920 PyObject * obj1 = 0 ;
33921 char *kwnames[] = {
33922 (char *) "self",(char *) "item", NULL
33923 };
33924
33925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33927 if (SWIG_arg_fail(1)) SWIG_fail;
33928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33929 if (SWIG_arg_fail(2)) SWIG_fail;
33930 {
33931 PyThreadState* __tstate = wxPyBeginAllowThreads();
33932 result = (bool)(arg1)->Destroy(arg2);
33933
33934 wxPyEndAllowThreads(__tstate);
33935 if (PyErr_Occurred()) SWIG_fail;
33936 }
33937 {
33938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33939 }
33940 return resultobj;
33941 fail:
33942 return NULL;
33943 }
33944
33945
33946 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33947 PyObject *resultobj;
33948 wxMenu *arg1 = (wxMenu *) 0 ;
33949 size_t result;
33950 PyObject * obj0 = 0 ;
33951 char *kwnames[] = {
33952 (char *) "self", NULL
33953 };
33954
33955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33957 if (SWIG_arg_fail(1)) SWIG_fail;
33958 {
33959 PyThreadState* __tstate = wxPyBeginAllowThreads();
33960 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33961
33962 wxPyEndAllowThreads(__tstate);
33963 if (PyErr_Occurred()) SWIG_fail;
33964 }
33965 {
33966 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33967 }
33968 return resultobj;
33969 fail:
33970 return NULL;
33971 }
33972
33973
33974 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33975 PyObject *resultobj;
33976 wxMenu *arg1 = (wxMenu *) 0 ;
33977 PyObject *result;
33978 PyObject * obj0 = 0 ;
33979 char *kwnames[] = {
33980 (char *) "self", NULL
33981 };
33982
33983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33985 if (SWIG_arg_fail(1)) SWIG_fail;
33986 {
33987 PyThreadState* __tstate = wxPyBeginAllowThreads();
33988 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33989
33990 wxPyEndAllowThreads(__tstate);
33991 if (PyErr_Occurred()) SWIG_fail;
33992 }
33993 resultobj = result;
33994 return resultobj;
33995 fail:
33996 return NULL;
33997 }
33998
33999
34000 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34001 PyObject *resultobj;
34002 wxMenu *arg1 = (wxMenu *) 0 ;
34003 wxString *arg2 = 0 ;
34004 int result;
34005 bool temp2 = false ;
34006 PyObject * obj0 = 0 ;
34007 PyObject * obj1 = 0 ;
34008 char *kwnames[] = {
34009 (char *) "self",(char *) "item", NULL
34010 };
34011
34012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",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 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34023
34024 wxPyEndAllowThreads(__tstate);
34025 if (PyErr_Occurred()) SWIG_fail;
34026 }
34027 {
34028 resultobj = SWIG_From_int((int)(result));
34029 }
34030 {
34031 if (temp2)
34032 delete arg2;
34033 }
34034 return resultobj;
34035 fail:
34036 {
34037 if (temp2)
34038 delete arg2;
34039 }
34040 return NULL;
34041 }
34042
34043
34044 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34045 PyObject *resultobj;
34046 wxMenu *arg1 = (wxMenu *) 0 ;
34047 int arg2 ;
34048 wxMenuItem *result;
34049 PyObject * obj0 = 0 ;
34050 PyObject * obj1 = 0 ;
34051 char *kwnames[] = {
34052 (char *) "self",(char *) "id", NULL
34053 };
34054
34055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34057 if (SWIG_arg_fail(1)) SWIG_fail;
34058 {
34059 arg2 = (int)(SWIG_As_int(obj1));
34060 if (SWIG_arg_fail(2)) SWIG_fail;
34061 }
34062 {
34063 PyThreadState* __tstate = wxPyBeginAllowThreads();
34064 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34065
34066 wxPyEndAllowThreads(__tstate);
34067 if (PyErr_Occurred()) SWIG_fail;
34068 }
34069 {
34070 resultobj = wxPyMake_wxObject(result, 0);
34071 }
34072 return resultobj;
34073 fail:
34074 return NULL;
34075 }
34076
34077
34078 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34079 PyObject *resultobj;
34080 wxMenu *arg1 = (wxMenu *) 0 ;
34081 size_t arg2 ;
34082 wxMenuItem *result;
34083 PyObject * obj0 = 0 ;
34084 PyObject * obj1 = 0 ;
34085 char *kwnames[] = {
34086 (char *) "self",(char *) "position", NULL
34087 };
34088
34089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34091 if (SWIG_arg_fail(1)) SWIG_fail;
34092 {
34093 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34094 if (SWIG_arg_fail(2)) SWIG_fail;
34095 }
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34099
34100 wxPyEndAllowThreads(__tstate);
34101 if (PyErr_Occurred()) SWIG_fail;
34102 }
34103 {
34104 resultobj = wxPyMake_wxObject(result, 0);
34105 }
34106 return resultobj;
34107 fail:
34108 return NULL;
34109 }
34110
34111
34112 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34113 PyObject *resultobj;
34114 wxMenu *arg1 = (wxMenu *) 0 ;
34115 int arg2 ;
34116 bool arg3 ;
34117 PyObject * obj0 = 0 ;
34118 PyObject * obj1 = 0 ;
34119 PyObject * obj2 = 0 ;
34120 char *kwnames[] = {
34121 (char *) "self",(char *) "id",(char *) "enable", NULL
34122 };
34123
34124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34126 if (SWIG_arg_fail(1)) SWIG_fail;
34127 {
34128 arg2 = (int)(SWIG_As_int(obj1));
34129 if (SWIG_arg_fail(2)) SWIG_fail;
34130 }
34131 {
34132 arg3 = (bool)(SWIG_As_bool(obj2));
34133 if (SWIG_arg_fail(3)) SWIG_fail;
34134 }
34135 {
34136 PyThreadState* __tstate = wxPyBeginAllowThreads();
34137 (arg1)->Enable(arg2,arg3);
34138
34139 wxPyEndAllowThreads(__tstate);
34140 if (PyErr_Occurred()) SWIG_fail;
34141 }
34142 Py_INCREF(Py_None); resultobj = Py_None;
34143 return resultobj;
34144 fail:
34145 return NULL;
34146 }
34147
34148
34149 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34150 PyObject *resultobj;
34151 wxMenu *arg1 = (wxMenu *) 0 ;
34152 int arg2 ;
34153 bool result;
34154 PyObject * obj0 = 0 ;
34155 PyObject * obj1 = 0 ;
34156 char *kwnames[] = {
34157 (char *) "self",(char *) "id", NULL
34158 };
34159
34160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34162 if (SWIG_arg_fail(1)) SWIG_fail;
34163 {
34164 arg2 = (int)(SWIG_As_int(obj1));
34165 if (SWIG_arg_fail(2)) SWIG_fail;
34166 }
34167 {
34168 PyThreadState* __tstate = wxPyBeginAllowThreads();
34169 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34170
34171 wxPyEndAllowThreads(__tstate);
34172 if (PyErr_Occurred()) SWIG_fail;
34173 }
34174 {
34175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34176 }
34177 return resultobj;
34178 fail:
34179 return NULL;
34180 }
34181
34182
34183 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34184 PyObject *resultobj;
34185 wxMenu *arg1 = (wxMenu *) 0 ;
34186 int arg2 ;
34187 bool arg3 ;
34188 PyObject * obj0 = 0 ;
34189 PyObject * obj1 = 0 ;
34190 PyObject * obj2 = 0 ;
34191 char *kwnames[] = {
34192 (char *) "self",(char *) "id",(char *) "check", NULL
34193 };
34194
34195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34197 if (SWIG_arg_fail(1)) SWIG_fail;
34198 {
34199 arg2 = (int)(SWIG_As_int(obj1));
34200 if (SWIG_arg_fail(2)) SWIG_fail;
34201 }
34202 {
34203 arg3 = (bool)(SWIG_As_bool(obj2));
34204 if (SWIG_arg_fail(3)) SWIG_fail;
34205 }
34206 {
34207 PyThreadState* __tstate = wxPyBeginAllowThreads();
34208 (arg1)->Check(arg2,arg3);
34209
34210 wxPyEndAllowThreads(__tstate);
34211 if (PyErr_Occurred()) SWIG_fail;
34212 }
34213 Py_INCREF(Py_None); resultobj = Py_None;
34214 return resultobj;
34215 fail:
34216 return NULL;
34217 }
34218
34219
34220 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34221 PyObject *resultobj;
34222 wxMenu *arg1 = (wxMenu *) 0 ;
34223 int arg2 ;
34224 bool result;
34225 PyObject * obj0 = 0 ;
34226 PyObject * obj1 = 0 ;
34227 char *kwnames[] = {
34228 (char *) "self",(char *) "id", NULL
34229 };
34230
34231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34233 if (SWIG_arg_fail(1)) SWIG_fail;
34234 {
34235 arg2 = (int)(SWIG_As_int(obj1));
34236 if (SWIG_arg_fail(2)) SWIG_fail;
34237 }
34238 {
34239 PyThreadState* __tstate = wxPyBeginAllowThreads();
34240 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34241
34242 wxPyEndAllowThreads(__tstate);
34243 if (PyErr_Occurred()) SWIG_fail;
34244 }
34245 {
34246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34247 }
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34255 PyObject *resultobj;
34256 wxMenu *arg1 = (wxMenu *) 0 ;
34257 int arg2 ;
34258 wxString *arg3 = 0 ;
34259 bool temp3 = false ;
34260 PyObject * obj0 = 0 ;
34261 PyObject * obj1 = 0 ;
34262 PyObject * obj2 = 0 ;
34263 char *kwnames[] = {
34264 (char *) "self",(char *) "id",(char *) "label", NULL
34265 };
34266
34267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34269 if (SWIG_arg_fail(1)) SWIG_fail;
34270 {
34271 arg2 = (int)(SWIG_As_int(obj1));
34272 if (SWIG_arg_fail(2)) SWIG_fail;
34273 }
34274 {
34275 arg3 = wxString_in_helper(obj2);
34276 if (arg3 == NULL) SWIG_fail;
34277 temp3 = true;
34278 }
34279 {
34280 PyThreadState* __tstate = wxPyBeginAllowThreads();
34281 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34282
34283 wxPyEndAllowThreads(__tstate);
34284 if (PyErr_Occurred()) SWIG_fail;
34285 }
34286 Py_INCREF(Py_None); resultobj = Py_None;
34287 {
34288 if (temp3)
34289 delete arg3;
34290 }
34291 return resultobj;
34292 fail:
34293 {
34294 if (temp3)
34295 delete arg3;
34296 }
34297 return NULL;
34298 }
34299
34300
34301 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34302 PyObject *resultobj;
34303 wxMenu *arg1 = (wxMenu *) 0 ;
34304 int arg2 ;
34305 wxString result;
34306 PyObject * obj0 = 0 ;
34307 PyObject * obj1 = 0 ;
34308 char *kwnames[] = {
34309 (char *) "self",(char *) "id", NULL
34310 };
34311
34312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
34317 if (SWIG_arg_fail(2)) SWIG_fail;
34318 }
34319 {
34320 PyThreadState* __tstate = wxPyBeginAllowThreads();
34321 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34322
34323 wxPyEndAllowThreads(__tstate);
34324 if (PyErr_Occurred()) SWIG_fail;
34325 }
34326 {
34327 #if wxUSE_UNICODE
34328 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34329 #else
34330 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34331 #endif
34332 }
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34340 PyObject *resultobj;
34341 wxMenu *arg1 = (wxMenu *) 0 ;
34342 int arg2 ;
34343 wxString *arg3 = 0 ;
34344 bool temp3 = false ;
34345 PyObject * obj0 = 0 ;
34346 PyObject * obj1 = 0 ;
34347 PyObject * obj2 = 0 ;
34348 char *kwnames[] = {
34349 (char *) "self",(char *) "id",(char *) "helpString", NULL
34350 };
34351
34352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34354 if (SWIG_arg_fail(1)) SWIG_fail;
34355 {
34356 arg2 = (int)(SWIG_As_int(obj1));
34357 if (SWIG_arg_fail(2)) SWIG_fail;
34358 }
34359 {
34360 arg3 = wxString_in_helper(obj2);
34361 if (arg3 == NULL) SWIG_fail;
34362 temp3 = true;
34363 }
34364 {
34365 PyThreadState* __tstate = wxPyBeginAllowThreads();
34366 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34367
34368 wxPyEndAllowThreads(__tstate);
34369 if (PyErr_Occurred()) SWIG_fail;
34370 }
34371 Py_INCREF(Py_None); resultobj = Py_None;
34372 {
34373 if (temp3)
34374 delete arg3;
34375 }
34376 return resultobj;
34377 fail:
34378 {
34379 if (temp3)
34380 delete arg3;
34381 }
34382 return NULL;
34383 }
34384
34385
34386 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34387 PyObject *resultobj;
34388 wxMenu *arg1 = (wxMenu *) 0 ;
34389 int arg2 ;
34390 wxString result;
34391 PyObject * obj0 = 0 ;
34392 PyObject * obj1 = 0 ;
34393 char *kwnames[] = {
34394 (char *) "self",(char *) "id", NULL
34395 };
34396
34397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34399 if (SWIG_arg_fail(1)) SWIG_fail;
34400 {
34401 arg2 = (int)(SWIG_As_int(obj1));
34402 if (SWIG_arg_fail(2)) SWIG_fail;
34403 }
34404 {
34405 PyThreadState* __tstate = wxPyBeginAllowThreads();
34406 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34407
34408 wxPyEndAllowThreads(__tstate);
34409 if (PyErr_Occurred()) SWIG_fail;
34410 }
34411 {
34412 #if wxUSE_UNICODE
34413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34414 #else
34415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34416 #endif
34417 }
34418 return resultobj;
34419 fail:
34420 return NULL;
34421 }
34422
34423
34424 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34425 PyObject *resultobj;
34426 wxMenu *arg1 = (wxMenu *) 0 ;
34427 wxString *arg2 = 0 ;
34428 bool temp2 = false ;
34429 PyObject * obj0 = 0 ;
34430 PyObject * obj1 = 0 ;
34431 char *kwnames[] = {
34432 (char *) "self",(char *) "title", NULL
34433 };
34434
34435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34437 if (SWIG_arg_fail(1)) SWIG_fail;
34438 {
34439 arg2 = wxString_in_helper(obj1);
34440 if (arg2 == NULL) SWIG_fail;
34441 temp2 = true;
34442 }
34443 {
34444 PyThreadState* __tstate = wxPyBeginAllowThreads();
34445 (arg1)->SetTitle((wxString const &)*arg2);
34446
34447 wxPyEndAllowThreads(__tstate);
34448 if (PyErr_Occurred()) SWIG_fail;
34449 }
34450 Py_INCREF(Py_None); resultobj = Py_None;
34451 {
34452 if (temp2)
34453 delete arg2;
34454 }
34455 return resultobj;
34456 fail:
34457 {
34458 if (temp2)
34459 delete arg2;
34460 }
34461 return NULL;
34462 }
34463
34464
34465 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34466 PyObject *resultobj;
34467 wxMenu *arg1 = (wxMenu *) 0 ;
34468 wxString result;
34469 PyObject * obj0 = 0 ;
34470 char *kwnames[] = {
34471 (char *) "self", NULL
34472 };
34473
34474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34476 if (SWIG_arg_fail(1)) SWIG_fail;
34477 {
34478 PyThreadState* __tstate = wxPyBeginAllowThreads();
34479 result = ((wxMenu const *)arg1)->GetTitle();
34480
34481 wxPyEndAllowThreads(__tstate);
34482 if (PyErr_Occurred()) SWIG_fail;
34483 }
34484 {
34485 #if wxUSE_UNICODE
34486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34487 #else
34488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34489 #endif
34490 }
34491 return resultobj;
34492 fail:
34493 return NULL;
34494 }
34495
34496
34497 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34498 PyObject *resultobj;
34499 wxMenu *arg1 = (wxMenu *) 0 ;
34500 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34501 PyObject * obj0 = 0 ;
34502 PyObject * obj1 = 0 ;
34503 char *kwnames[] = {
34504 (char *) "self",(char *) "handler", NULL
34505 };
34506
34507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34509 if (SWIG_arg_fail(1)) SWIG_fail;
34510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34511 if (SWIG_arg_fail(2)) SWIG_fail;
34512 {
34513 PyThreadState* __tstate = wxPyBeginAllowThreads();
34514 (arg1)->SetEventHandler(arg2);
34515
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 Py_INCREF(Py_None); resultobj = Py_None;
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34527 PyObject *resultobj;
34528 wxMenu *arg1 = (wxMenu *) 0 ;
34529 wxEvtHandler *result;
34530 PyObject * obj0 = 0 ;
34531 char *kwnames[] = {
34532 (char *) "self", NULL
34533 };
34534
34535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34537 if (SWIG_arg_fail(1)) SWIG_fail;
34538 {
34539 PyThreadState* __tstate = wxPyBeginAllowThreads();
34540 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34541
34542 wxPyEndAllowThreads(__tstate);
34543 if (PyErr_Occurred()) SWIG_fail;
34544 }
34545 {
34546 resultobj = wxPyMake_wxObject(result, 0);
34547 }
34548 return resultobj;
34549 fail:
34550 return NULL;
34551 }
34552
34553
34554 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34555 PyObject *resultobj;
34556 wxMenu *arg1 = (wxMenu *) 0 ;
34557 wxWindow *arg2 = (wxWindow *) 0 ;
34558 PyObject * obj0 = 0 ;
34559 PyObject * obj1 = 0 ;
34560 char *kwnames[] = {
34561 (char *) "self",(char *) "win", NULL
34562 };
34563
34564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34566 if (SWIG_arg_fail(1)) SWIG_fail;
34567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34568 if (SWIG_arg_fail(2)) SWIG_fail;
34569 {
34570 PyThreadState* __tstate = wxPyBeginAllowThreads();
34571 (arg1)->SetInvokingWindow(arg2);
34572
34573 wxPyEndAllowThreads(__tstate);
34574 if (PyErr_Occurred()) SWIG_fail;
34575 }
34576 Py_INCREF(Py_None); resultobj = Py_None;
34577 return resultobj;
34578 fail:
34579 return NULL;
34580 }
34581
34582
34583 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34584 PyObject *resultobj;
34585 wxMenu *arg1 = (wxMenu *) 0 ;
34586 wxWindow *result;
34587 PyObject * obj0 = 0 ;
34588 char *kwnames[] = {
34589 (char *) "self", NULL
34590 };
34591
34592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34594 if (SWIG_arg_fail(1)) SWIG_fail;
34595 {
34596 PyThreadState* __tstate = wxPyBeginAllowThreads();
34597 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34598
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 {
34603 resultobj = wxPyMake_wxObject(result, 0);
34604 }
34605 return resultobj;
34606 fail:
34607 return NULL;
34608 }
34609
34610
34611 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34612 PyObject *resultobj;
34613 wxMenu *arg1 = (wxMenu *) 0 ;
34614 long result;
34615 PyObject * obj0 = 0 ;
34616 char *kwnames[] = {
34617 (char *) "self", NULL
34618 };
34619
34620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34622 if (SWIG_arg_fail(1)) SWIG_fail;
34623 {
34624 PyThreadState* __tstate = wxPyBeginAllowThreads();
34625 result = (long)((wxMenu const *)arg1)->GetStyle();
34626
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 {
34631 resultobj = SWIG_From_long((long)(result));
34632 }
34633 return resultobj;
34634 fail:
34635 return NULL;
34636 }
34637
34638
34639 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34640 PyObject *resultobj;
34641 wxMenu *arg1 = (wxMenu *) 0 ;
34642 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34643 PyObject * obj0 = 0 ;
34644 PyObject * obj1 = 0 ;
34645 char *kwnames[] = {
34646 (char *) "self",(char *) "source", NULL
34647 };
34648
34649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34651 if (SWIG_arg_fail(1)) SWIG_fail;
34652 if (obj1) {
34653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34654 if (SWIG_arg_fail(2)) SWIG_fail;
34655 }
34656 {
34657 PyThreadState* __tstate = wxPyBeginAllowThreads();
34658 (arg1)->UpdateUI(arg2);
34659
34660 wxPyEndAllowThreads(__tstate);
34661 if (PyErr_Occurred()) SWIG_fail;
34662 }
34663 Py_INCREF(Py_None); resultobj = Py_None;
34664 return resultobj;
34665 fail:
34666 return NULL;
34667 }
34668
34669
34670 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34671 PyObject *resultobj;
34672 wxMenu *arg1 = (wxMenu *) 0 ;
34673 wxMenuBar *result;
34674 PyObject * obj0 = 0 ;
34675 char *kwnames[] = {
34676 (char *) "self", NULL
34677 };
34678
34679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34681 if (SWIG_arg_fail(1)) SWIG_fail;
34682 {
34683 PyThreadState* __tstate = wxPyBeginAllowThreads();
34684 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34685
34686 wxPyEndAllowThreads(__tstate);
34687 if (PyErr_Occurred()) SWIG_fail;
34688 }
34689 {
34690 resultobj = wxPyMake_wxObject(result, 0);
34691 }
34692 return resultobj;
34693 fail:
34694 return NULL;
34695 }
34696
34697
34698 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34699 PyObject *resultobj;
34700 wxMenu *arg1 = (wxMenu *) 0 ;
34701 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34702 PyObject * obj0 = 0 ;
34703 PyObject * obj1 = 0 ;
34704 char *kwnames[] = {
34705 (char *) "self",(char *) "menubar", NULL
34706 };
34707
34708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34710 if (SWIG_arg_fail(1)) SWIG_fail;
34711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34712 if (SWIG_arg_fail(2)) SWIG_fail;
34713 {
34714 PyThreadState* __tstate = wxPyBeginAllowThreads();
34715 (arg1)->Attach(arg2);
34716
34717 wxPyEndAllowThreads(__tstate);
34718 if (PyErr_Occurred()) SWIG_fail;
34719 }
34720 Py_INCREF(Py_None); resultobj = Py_None;
34721 return resultobj;
34722 fail:
34723 return NULL;
34724 }
34725
34726
34727 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34728 PyObject *resultobj;
34729 wxMenu *arg1 = (wxMenu *) 0 ;
34730 PyObject * obj0 = 0 ;
34731 char *kwnames[] = {
34732 (char *) "self", NULL
34733 };
34734
34735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34737 if (SWIG_arg_fail(1)) SWIG_fail;
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 (arg1)->Detach();
34741
34742 wxPyEndAllowThreads(__tstate);
34743 if (PyErr_Occurred()) SWIG_fail;
34744 }
34745 Py_INCREF(Py_None); resultobj = Py_None;
34746 return resultobj;
34747 fail:
34748 return NULL;
34749 }
34750
34751
34752 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34753 PyObject *resultobj;
34754 wxMenu *arg1 = (wxMenu *) 0 ;
34755 bool result;
34756 PyObject * obj0 = 0 ;
34757 char *kwnames[] = {
34758 (char *) "self", NULL
34759 };
34760
34761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34763 if (SWIG_arg_fail(1)) SWIG_fail;
34764 {
34765 PyThreadState* __tstate = wxPyBeginAllowThreads();
34766 result = (bool)((wxMenu const *)arg1)->IsAttached();
34767
34768 wxPyEndAllowThreads(__tstate);
34769 if (PyErr_Occurred()) SWIG_fail;
34770 }
34771 {
34772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34773 }
34774 return resultobj;
34775 fail:
34776 return NULL;
34777 }
34778
34779
34780 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34781 PyObject *resultobj;
34782 wxMenu *arg1 = (wxMenu *) 0 ;
34783 wxMenu *arg2 = (wxMenu *) 0 ;
34784 PyObject * obj0 = 0 ;
34785 PyObject * obj1 = 0 ;
34786 char *kwnames[] = {
34787 (char *) "self",(char *) "parent", NULL
34788 };
34789
34790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34792 if (SWIG_arg_fail(1)) SWIG_fail;
34793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34794 if (SWIG_arg_fail(2)) SWIG_fail;
34795 {
34796 PyThreadState* __tstate = wxPyBeginAllowThreads();
34797 (arg1)->SetParent(arg2);
34798
34799 wxPyEndAllowThreads(__tstate);
34800 if (PyErr_Occurred()) SWIG_fail;
34801 }
34802 Py_INCREF(Py_None); resultobj = Py_None;
34803 return resultobj;
34804 fail:
34805 return NULL;
34806 }
34807
34808
34809 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34810 PyObject *resultobj;
34811 wxMenu *arg1 = (wxMenu *) 0 ;
34812 wxMenu *result;
34813 PyObject * obj0 = 0 ;
34814 char *kwnames[] = {
34815 (char *) "self", NULL
34816 };
34817
34818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34820 if (SWIG_arg_fail(1)) SWIG_fail;
34821 {
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34824
34825 wxPyEndAllowThreads(__tstate);
34826 if (PyErr_Occurred()) SWIG_fail;
34827 }
34828 {
34829 resultobj = wxPyMake_wxObject(result, 0);
34830 }
34831 return resultobj;
34832 fail:
34833 return NULL;
34834 }
34835
34836
34837 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34838 PyObject *obj;
34839 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34840 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34841 Py_INCREF(obj);
34842 return Py_BuildValue((char *)"");
34843 }
34844 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34845 PyObject *resultobj;
34846 long arg1 = (long) 0 ;
34847 wxMenuBar *result;
34848 PyObject * obj0 = 0 ;
34849 char *kwnames[] = {
34850 (char *) "style", NULL
34851 };
34852
34853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34854 if (obj0) {
34855 {
34856 arg1 = (long)(SWIG_As_long(obj0));
34857 if (SWIG_arg_fail(1)) SWIG_fail;
34858 }
34859 }
34860 {
34861 if (!wxPyCheckForApp()) SWIG_fail;
34862 PyThreadState* __tstate = wxPyBeginAllowThreads();
34863 result = (wxMenuBar *)new wxMenuBar(arg1);
34864
34865 wxPyEndAllowThreads(__tstate);
34866 if (PyErr_Occurred()) SWIG_fail;
34867 }
34868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34869 return resultobj;
34870 fail:
34871 return NULL;
34872 }
34873
34874
34875 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34876 PyObject *resultobj;
34877 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34878 wxMenu *arg2 = (wxMenu *) 0 ;
34879 wxString *arg3 = 0 ;
34880 bool result;
34881 bool temp3 = false ;
34882 PyObject * obj0 = 0 ;
34883 PyObject * obj1 = 0 ;
34884 PyObject * obj2 = 0 ;
34885 char *kwnames[] = {
34886 (char *) "self",(char *) "menu",(char *) "title", NULL
34887 };
34888
34889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34891 if (SWIG_arg_fail(1)) SWIG_fail;
34892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34893 if (SWIG_arg_fail(2)) SWIG_fail;
34894 {
34895 arg3 = wxString_in_helper(obj2);
34896 if (arg3 == NULL) SWIG_fail;
34897 temp3 = true;
34898 }
34899 {
34900 PyThreadState* __tstate = wxPyBeginAllowThreads();
34901 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34902
34903 wxPyEndAllowThreads(__tstate);
34904 if (PyErr_Occurred()) SWIG_fail;
34905 }
34906 {
34907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34908 }
34909 {
34910 if (temp3)
34911 delete arg3;
34912 }
34913 return resultobj;
34914 fail:
34915 {
34916 if (temp3)
34917 delete arg3;
34918 }
34919 return NULL;
34920 }
34921
34922
34923 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34924 PyObject *resultobj;
34925 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34926 size_t arg2 ;
34927 wxMenu *arg3 = (wxMenu *) 0 ;
34928 wxString *arg4 = 0 ;
34929 bool result;
34930 bool temp4 = false ;
34931 PyObject * obj0 = 0 ;
34932 PyObject * obj1 = 0 ;
34933 PyObject * obj2 = 0 ;
34934 PyObject * obj3 = 0 ;
34935 char *kwnames[] = {
34936 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34937 };
34938
34939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34941 if (SWIG_arg_fail(1)) SWIG_fail;
34942 {
34943 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34944 if (SWIG_arg_fail(2)) SWIG_fail;
34945 }
34946 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34947 if (SWIG_arg_fail(3)) SWIG_fail;
34948 {
34949 arg4 = wxString_in_helper(obj3);
34950 if (arg4 == NULL) SWIG_fail;
34951 temp4 = true;
34952 }
34953 {
34954 PyThreadState* __tstate = wxPyBeginAllowThreads();
34955 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34956
34957 wxPyEndAllowThreads(__tstate);
34958 if (PyErr_Occurred()) SWIG_fail;
34959 }
34960 {
34961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34962 }
34963 {
34964 if (temp4)
34965 delete arg4;
34966 }
34967 return resultobj;
34968 fail:
34969 {
34970 if (temp4)
34971 delete arg4;
34972 }
34973 return NULL;
34974 }
34975
34976
34977 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34978 PyObject *resultobj;
34979 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34980 size_t result;
34981 PyObject * obj0 = 0 ;
34982 char *kwnames[] = {
34983 (char *) "self", NULL
34984 };
34985
34986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34988 if (SWIG_arg_fail(1)) SWIG_fail;
34989 {
34990 PyThreadState* __tstate = wxPyBeginAllowThreads();
34991 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34992
34993 wxPyEndAllowThreads(__tstate);
34994 if (PyErr_Occurred()) SWIG_fail;
34995 }
34996 {
34997 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34998 }
34999 return resultobj;
35000 fail:
35001 return NULL;
35002 }
35003
35004
35005 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35006 PyObject *resultobj;
35007 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35008 size_t arg2 ;
35009 wxMenu *result;
35010 PyObject * obj0 = 0 ;
35011 PyObject * obj1 = 0 ;
35012 char *kwnames[] = {
35013 (char *) "self",(char *) "pos", NULL
35014 };
35015
35016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35018 if (SWIG_arg_fail(1)) SWIG_fail;
35019 {
35020 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35021 if (SWIG_arg_fail(2)) SWIG_fail;
35022 }
35023 {
35024 PyThreadState* __tstate = wxPyBeginAllowThreads();
35025 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35026
35027 wxPyEndAllowThreads(__tstate);
35028 if (PyErr_Occurred()) SWIG_fail;
35029 }
35030 {
35031 resultobj = wxPyMake_wxObject(result, 0);
35032 }
35033 return resultobj;
35034 fail:
35035 return NULL;
35036 }
35037
35038
35039 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35040 PyObject *resultobj;
35041 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35042 size_t arg2 ;
35043 wxMenu *arg3 = (wxMenu *) 0 ;
35044 wxString *arg4 = 0 ;
35045 wxMenu *result;
35046 bool temp4 = false ;
35047 PyObject * obj0 = 0 ;
35048 PyObject * obj1 = 0 ;
35049 PyObject * obj2 = 0 ;
35050 PyObject * obj3 = 0 ;
35051 char *kwnames[] = {
35052 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35053 };
35054
35055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35057 if (SWIG_arg_fail(1)) SWIG_fail;
35058 {
35059 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35060 if (SWIG_arg_fail(2)) SWIG_fail;
35061 }
35062 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35063 if (SWIG_arg_fail(3)) SWIG_fail;
35064 {
35065 arg4 = wxString_in_helper(obj3);
35066 if (arg4 == NULL) SWIG_fail;
35067 temp4 = true;
35068 }
35069 {
35070 PyThreadState* __tstate = wxPyBeginAllowThreads();
35071 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35072
35073 wxPyEndAllowThreads(__tstate);
35074 if (PyErr_Occurred()) SWIG_fail;
35075 }
35076 {
35077 resultobj = wxPyMake_wxObject(result, 0);
35078 }
35079 {
35080 if (temp4)
35081 delete arg4;
35082 }
35083 return resultobj;
35084 fail:
35085 {
35086 if (temp4)
35087 delete arg4;
35088 }
35089 return NULL;
35090 }
35091
35092
35093 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35094 PyObject *resultobj;
35095 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35096 size_t arg2 ;
35097 wxMenu *result;
35098 PyObject * obj0 = 0 ;
35099 PyObject * obj1 = 0 ;
35100 char *kwnames[] = {
35101 (char *) "self",(char *) "pos", NULL
35102 };
35103
35104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35106 if (SWIG_arg_fail(1)) SWIG_fail;
35107 {
35108 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35109 if (SWIG_arg_fail(2)) SWIG_fail;
35110 }
35111 {
35112 PyThreadState* __tstate = wxPyBeginAllowThreads();
35113 result = (wxMenu *)(arg1)->Remove(arg2);
35114
35115 wxPyEndAllowThreads(__tstate);
35116 if (PyErr_Occurred()) SWIG_fail;
35117 }
35118 {
35119 resultobj = wxPyMake_wxObject(result, 0);
35120 }
35121 return resultobj;
35122 fail:
35123 return NULL;
35124 }
35125
35126
35127 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35128 PyObject *resultobj;
35129 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35130 size_t arg2 ;
35131 bool arg3 ;
35132 PyObject * obj0 = 0 ;
35133 PyObject * obj1 = 0 ;
35134 PyObject * obj2 = 0 ;
35135 char *kwnames[] = {
35136 (char *) "self",(char *) "pos",(char *) "enable", NULL
35137 };
35138
35139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35141 if (SWIG_arg_fail(1)) SWIG_fail;
35142 {
35143 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35144 if (SWIG_arg_fail(2)) SWIG_fail;
35145 }
35146 {
35147 arg3 = (bool)(SWIG_As_bool(obj2));
35148 if (SWIG_arg_fail(3)) SWIG_fail;
35149 }
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 (arg1)->EnableTop(arg2,arg3);
35153
35154 wxPyEndAllowThreads(__tstate);
35155 if (PyErr_Occurred()) SWIG_fail;
35156 }
35157 Py_INCREF(Py_None); resultobj = Py_None;
35158 return resultobj;
35159 fail:
35160 return NULL;
35161 }
35162
35163
35164 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35165 PyObject *resultobj;
35166 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35167 size_t arg2 ;
35168 bool result;
35169 PyObject * obj0 = 0 ;
35170 PyObject * obj1 = 0 ;
35171 char *kwnames[] = {
35172 (char *) "self",(char *) "pos", NULL
35173 };
35174
35175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35177 if (SWIG_arg_fail(1)) SWIG_fail;
35178 {
35179 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35180 if (SWIG_arg_fail(2)) SWIG_fail;
35181 }
35182 {
35183 PyThreadState* __tstate = wxPyBeginAllowThreads();
35184 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35185
35186 wxPyEndAllowThreads(__tstate);
35187 if (PyErr_Occurred()) SWIG_fail;
35188 }
35189 {
35190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35191 }
35192 return resultobj;
35193 fail:
35194 return NULL;
35195 }
35196
35197
35198 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35199 PyObject *resultobj;
35200 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35201 size_t arg2 ;
35202 wxString *arg3 = 0 ;
35203 bool temp3 = false ;
35204 PyObject * obj0 = 0 ;
35205 PyObject * obj1 = 0 ;
35206 PyObject * obj2 = 0 ;
35207 char *kwnames[] = {
35208 (char *) "self",(char *) "pos",(char *) "label", NULL
35209 };
35210
35211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35213 if (SWIG_arg_fail(1)) SWIG_fail;
35214 {
35215 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35216 if (SWIG_arg_fail(2)) SWIG_fail;
35217 }
35218 {
35219 arg3 = wxString_in_helper(obj2);
35220 if (arg3 == NULL) SWIG_fail;
35221 temp3 = true;
35222 }
35223 {
35224 PyThreadState* __tstate = wxPyBeginAllowThreads();
35225 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35226
35227 wxPyEndAllowThreads(__tstate);
35228 if (PyErr_Occurred()) SWIG_fail;
35229 }
35230 Py_INCREF(Py_None); resultobj = Py_None;
35231 {
35232 if (temp3)
35233 delete arg3;
35234 }
35235 return resultobj;
35236 fail:
35237 {
35238 if (temp3)
35239 delete arg3;
35240 }
35241 return NULL;
35242 }
35243
35244
35245 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35246 PyObject *resultobj;
35247 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35248 size_t arg2 ;
35249 wxString result;
35250 PyObject * obj0 = 0 ;
35251 PyObject * obj1 = 0 ;
35252 char *kwnames[] = {
35253 (char *) "self",(char *) "pos", NULL
35254 };
35255
35256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35258 if (SWIG_arg_fail(1)) SWIG_fail;
35259 {
35260 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35261 if (SWIG_arg_fail(2)) SWIG_fail;
35262 }
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35266
35267 wxPyEndAllowThreads(__tstate);
35268 if (PyErr_Occurred()) SWIG_fail;
35269 }
35270 {
35271 #if wxUSE_UNICODE
35272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35273 #else
35274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35275 #endif
35276 }
35277 return resultobj;
35278 fail:
35279 return NULL;
35280 }
35281
35282
35283 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35284 PyObject *resultobj;
35285 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35286 wxString *arg2 = 0 ;
35287 wxString *arg3 = 0 ;
35288 int result;
35289 bool temp2 = false ;
35290 bool temp3 = false ;
35291 PyObject * obj0 = 0 ;
35292 PyObject * obj1 = 0 ;
35293 PyObject * obj2 = 0 ;
35294 char *kwnames[] = {
35295 (char *) "self",(char *) "menu",(char *) "item", NULL
35296 };
35297
35298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35300 if (SWIG_arg_fail(1)) SWIG_fail;
35301 {
35302 arg2 = wxString_in_helper(obj1);
35303 if (arg2 == NULL) SWIG_fail;
35304 temp2 = true;
35305 }
35306 {
35307 arg3 = wxString_in_helper(obj2);
35308 if (arg3 == NULL) SWIG_fail;
35309 temp3 = true;
35310 }
35311 {
35312 PyThreadState* __tstate = wxPyBeginAllowThreads();
35313 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35314
35315 wxPyEndAllowThreads(__tstate);
35316 if (PyErr_Occurred()) SWIG_fail;
35317 }
35318 {
35319 resultobj = SWIG_From_int((int)(result));
35320 }
35321 {
35322 if (temp2)
35323 delete arg2;
35324 }
35325 {
35326 if (temp3)
35327 delete arg3;
35328 }
35329 return resultobj;
35330 fail:
35331 {
35332 if (temp2)
35333 delete arg2;
35334 }
35335 {
35336 if (temp3)
35337 delete arg3;
35338 }
35339 return NULL;
35340 }
35341
35342
35343 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35344 PyObject *resultobj;
35345 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35346 int arg2 ;
35347 wxMenuItem *result;
35348 PyObject * obj0 = 0 ;
35349 PyObject * obj1 = 0 ;
35350 char *kwnames[] = {
35351 (char *) "self",(char *) "id", NULL
35352 };
35353
35354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35356 if (SWIG_arg_fail(1)) SWIG_fail;
35357 {
35358 arg2 = (int)(SWIG_As_int(obj1));
35359 if (SWIG_arg_fail(2)) SWIG_fail;
35360 }
35361 {
35362 PyThreadState* __tstate = wxPyBeginAllowThreads();
35363 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35364
35365 wxPyEndAllowThreads(__tstate);
35366 if (PyErr_Occurred()) SWIG_fail;
35367 }
35368 {
35369 resultobj = wxPyMake_wxObject(result, 0);
35370 }
35371 return resultobj;
35372 fail:
35373 return NULL;
35374 }
35375
35376
35377 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35378 PyObject *resultobj;
35379 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35380 wxString *arg2 = 0 ;
35381 int result;
35382 bool temp2 = false ;
35383 PyObject * obj0 = 0 ;
35384 PyObject * obj1 = 0 ;
35385 char *kwnames[] = {
35386 (char *) "self",(char *) "title", NULL
35387 };
35388
35389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35391 if (SWIG_arg_fail(1)) SWIG_fail;
35392 {
35393 arg2 = wxString_in_helper(obj1);
35394 if (arg2 == NULL) SWIG_fail;
35395 temp2 = true;
35396 }
35397 {
35398 PyThreadState* __tstate = wxPyBeginAllowThreads();
35399 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35400
35401 wxPyEndAllowThreads(__tstate);
35402 if (PyErr_Occurred()) SWIG_fail;
35403 }
35404 {
35405 resultobj = SWIG_From_int((int)(result));
35406 }
35407 {
35408 if (temp2)
35409 delete arg2;
35410 }
35411 return resultobj;
35412 fail:
35413 {
35414 if (temp2)
35415 delete arg2;
35416 }
35417 return NULL;
35418 }
35419
35420
35421 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35422 PyObject *resultobj;
35423 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35424 int arg2 ;
35425 bool arg3 ;
35426 PyObject * obj0 = 0 ;
35427 PyObject * obj1 = 0 ;
35428 PyObject * obj2 = 0 ;
35429 char *kwnames[] = {
35430 (char *) "self",(char *) "id",(char *) "enable", NULL
35431 };
35432
35433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35435 if (SWIG_arg_fail(1)) SWIG_fail;
35436 {
35437 arg2 = (int)(SWIG_As_int(obj1));
35438 if (SWIG_arg_fail(2)) SWIG_fail;
35439 }
35440 {
35441 arg3 = (bool)(SWIG_As_bool(obj2));
35442 if (SWIG_arg_fail(3)) SWIG_fail;
35443 }
35444 {
35445 PyThreadState* __tstate = wxPyBeginAllowThreads();
35446 (arg1)->Enable(arg2,arg3);
35447
35448 wxPyEndAllowThreads(__tstate);
35449 if (PyErr_Occurred()) SWIG_fail;
35450 }
35451 Py_INCREF(Py_None); resultobj = Py_None;
35452 return resultobj;
35453 fail:
35454 return NULL;
35455 }
35456
35457
35458 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35459 PyObject *resultobj;
35460 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35461 int arg2 ;
35462 bool arg3 ;
35463 PyObject * obj0 = 0 ;
35464 PyObject * obj1 = 0 ;
35465 PyObject * obj2 = 0 ;
35466 char *kwnames[] = {
35467 (char *) "self",(char *) "id",(char *) "check", NULL
35468 };
35469
35470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35472 if (SWIG_arg_fail(1)) SWIG_fail;
35473 {
35474 arg2 = (int)(SWIG_As_int(obj1));
35475 if (SWIG_arg_fail(2)) SWIG_fail;
35476 }
35477 {
35478 arg3 = (bool)(SWIG_As_bool(obj2));
35479 if (SWIG_arg_fail(3)) SWIG_fail;
35480 }
35481 {
35482 PyThreadState* __tstate = wxPyBeginAllowThreads();
35483 (arg1)->Check(arg2,arg3);
35484
35485 wxPyEndAllowThreads(__tstate);
35486 if (PyErr_Occurred()) SWIG_fail;
35487 }
35488 Py_INCREF(Py_None); resultobj = Py_None;
35489 return resultobj;
35490 fail:
35491 return NULL;
35492 }
35493
35494
35495 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35496 PyObject *resultobj;
35497 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35498 int arg2 ;
35499 bool result;
35500 PyObject * obj0 = 0 ;
35501 PyObject * obj1 = 0 ;
35502 char *kwnames[] = {
35503 (char *) "self",(char *) "id", NULL
35504 };
35505
35506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35508 if (SWIG_arg_fail(1)) SWIG_fail;
35509 {
35510 arg2 = (int)(SWIG_As_int(obj1));
35511 if (SWIG_arg_fail(2)) SWIG_fail;
35512 }
35513 {
35514 PyThreadState* __tstate = wxPyBeginAllowThreads();
35515 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35516
35517 wxPyEndAllowThreads(__tstate);
35518 if (PyErr_Occurred()) SWIG_fail;
35519 }
35520 {
35521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35522 }
35523 return resultobj;
35524 fail:
35525 return NULL;
35526 }
35527
35528
35529 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35530 PyObject *resultobj;
35531 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35532 int arg2 ;
35533 bool result;
35534 PyObject * obj0 = 0 ;
35535 PyObject * obj1 = 0 ;
35536 char *kwnames[] = {
35537 (char *) "self",(char *) "id", NULL
35538 };
35539
35540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35542 if (SWIG_arg_fail(1)) SWIG_fail;
35543 {
35544 arg2 = (int)(SWIG_As_int(obj1));
35545 if (SWIG_arg_fail(2)) SWIG_fail;
35546 }
35547 {
35548 PyThreadState* __tstate = wxPyBeginAllowThreads();
35549 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35550
35551 wxPyEndAllowThreads(__tstate);
35552 if (PyErr_Occurred()) SWIG_fail;
35553 }
35554 {
35555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35556 }
35557 return resultobj;
35558 fail:
35559 return NULL;
35560 }
35561
35562
35563 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35564 PyObject *resultobj;
35565 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35566 int arg2 ;
35567 wxString *arg3 = 0 ;
35568 bool temp3 = false ;
35569 PyObject * obj0 = 0 ;
35570 PyObject * obj1 = 0 ;
35571 PyObject * obj2 = 0 ;
35572 char *kwnames[] = {
35573 (char *) "self",(char *) "id",(char *) "label", NULL
35574 };
35575
35576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35578 if (SWIG_arg_fail(1)) SWIG_fail;
35579 {
35580 arg2 = (int)(SWIG_As_int(obj1));
35581 if (SWIG_arg_fail(2)) SWIG_fail;
35582 }
35583 {
35584 arg3 = wxString_in_helper(obj2);
35585 if (arg3 == NULL) SWIG_fail;
35586 temp3 = true;
35587 }
35588 {
35589 PyThreadState* __tstate = wxPyBeginAllowThreads();
35590 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35591
35592 wxPyEndAllowThreads(__tstate);
35593 if (PyErr_Occurred()) SWIG_fail;
35594 }
35595 Py_INCREF(Py_None); resultobj = Py_None;
35596 {
35597 if (temp3)
35598 delete arg3;
35599 }
35600 return resultobj;
35601 fail:
35602 {
35603 if (temp3)
35604 delete arg3;
35605 }
35606 return NULL;
35607 }
35608
35609
35610 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35611 PyObject *resultobj;
35612 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35613 int arg2 ;
35614 wxString result;
35615 PyObject * obj0 = 0 ;
35616 PyObject * obj1 = 0 ;
35617 char *kwnames[] = {
35618 (char *) "self",(char *) "id", NULL
35619 };
35620
35621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35623 if (SWIG_arg_fail(1)) SWIG_fail;
35624 {
35625 arg2 = (int)(SWIG_As_int(obj1));
35626 if (SWIG_arg_fail(2)) SWIG_fail;
35627 }
35628 {
35629 PyThreadState* __tstate = wxPyBeginAllowThreads();
35630 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35631
35632 wxPyEndAllowThreads(__tstate);
35633 if (PyErr_Occurred()) SWIG_fail;
35634 }
35635 {
35636 #if wxUSE_UNICODE
35637 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35638 #else
35639 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35640 #endif
35641 }
35642 return resultobj;
35643 fail:
35644 return NULL;
35645 }
35646
35647
35648 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35649 PyObject *resultobj;
35650 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35651 int arg2 ;
35652 wxString *arg3 = 0 ;
35653 bool temp3 = false ;
35654 PyObject * obj0 = 0 ;
35655 PyObject * obj1 = 0 ;
35656 PyObject * obj2 = 0 ;
35657 char *kwnames[] = {
35658 (char *) "self",(char *) "id",(char *) "helpString", NULL
35659 };
35660
35661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35663 if (SWIG_arg_fail(1)) SWIG_fail;
35664 {
35665 arg2 = (int)(SWIG_As_int(obj1));
35666 if (SWIG_arg_fail(2)) SWIG_fail;
35667 }
35668 {
35669 arg3 = wxString_in_helper(obj2);
35670 if (arg3 == NULL) SWIG_fail;
35671 temp3 = true;
35672 }
35673 {
35674 PyThreadState* __tstate = wxPyBeginAllowThreads();
35675 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35676
35677 wxPyEndAllowThreads(__tstate);
35678 if (PyErr_Occurred()) SWIG_fail;
35679 }
35680 Py_INCREF(Py_None); resultobj = Py_None;
35681 {
35682 if (temp3)
35683 delete arg3;
35684 }
35685 return resultobj;
35686 fail:
35687 {
35688 if (temp3)
35689 delete arg3;
35690 }
35691 return NULL;
35692 }
35693
35694
35695 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35696 PyObject *resultobj;
35697 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35698 int arg2 ;
35699 wxString result;
35700 PyObject * obj0 = 0 ;
35701 PyObject * obj1 = 0 ;
35702 char *kwnames[] = {
35703 (char *) "self",(char *) "id", NULL
35704 };
35705
35706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35708 if (SWIG_arg_fail(1)) SWIG_fail;
35709 {
35710 arg2 = (int)(SWIG_As_int(obj1));
35711 if (SWIG_arg_fail(2)) SWIG_fail;
35712 }
35713 {
35714 PyThreadState* __tstate = wxPyBeginAllowThreads();
35715 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35716
35717 wxPyEndAllowThreads(__tstate);
35718 if (PyErr_Occurred()) SWIG_fail;
35719 }
35720 {
35721 #if wxUSE_UNICODE
35722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35723 #else
35724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35725 #endif
35726 }
35727 return resultobj;
35728 fail:
35729 return NULL;
35730 }
35731
35732
35733 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35734 PyObject *resultobj;
35735 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35736 wxFrame *result;
35737 PyObject * obj0 = 0 ;
35738 char *kwnames[] = {
35739 (char *) "self", NULL
35740 };
35741
35742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35744 if (SWIG_arg_fail(1)) SWIG_fail;
35745 {
35746 PyThreadState* __tstate = wxPyBeginAllowThreads();
35747 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35748
35749 wxPyEndAllowThreads(__tstate);
35750 if (PyErr_Occurred()) SWIG_fail;
35751 }
35752 {
35753 resultobj = wxPyMake_wxObject(result, 0);
35754 }
35755 return resultobj;
35756 fail:
35757 return NULL;
35758 }
35759
35760
35761 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35762 PyObject *resultobj;
35763 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35764 bool result;
35765 PyObject * obj0 = 0 ;
35766 char *kwnames[] = {
35767 (char *) "self", NULL
35768 };
35769
35770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35772 if (SWIG_arg_fail(1)) SWIG_fail;
35773 {
35774 PyThreadState* __tstate = wxPyBeginAllowThreads();
35775 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35776
35777 wxPyEndAllowThreads(__tstate);
35778 if (PyErr_Occurred()) SWIG_fail;
35779 }
35780 {
35781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35782 }
35783 return resultobj;
35784 fail:
35785 return NULL;
35786 }
35787
35788
35789 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35790 PyObject *resultobj;
35791 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35792 wxFrame *arg2 = (wxFrame *) 0 ;
35793 PyObject * obj0 = 0 ;
35794 PyObject * obj1 = 0 ;
35795 char *kwnames[] = {
35796 (char *) "self",(char *) "frame", NULL
35797 };
35798
35799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35801 if (SWIG_arg_fail(1)) SWIG_fail;
35802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35803 if (SWIG_arg_fail(2)) SWIG_fail;
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 (arg1)->Attach(arg2);
35807
35808 wxPyEndAllowThreads(__tstate);
35809 if (PyErr_Occurred()) SWIG_fail;
35810 }
35811 Py_INCREF(Py_None); resultobj = Py_None;
35812 return resultobj;
35813 fail:
35814 return NULL;
35815 }
35816
35817
35818 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35819 PyObject *resultobj;
35820 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35821 PyObject * obj0 = 0 ;
35822 char *kwnames[] = {
35823 (char *) "self", NULL
35824 };
35825
35826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35828 if (SWIG_arg_fail(1)) SWIG_fail;
35829 {
35830 PyThreadState* __tstate = wxPyBeginAllowThreads();
35831 (arg1)->Detach();
35832
35833 wxPyEndAllowThreads(__tstate);
35834 if (PyErr_Occurred()) SWIG_fail;
35835 }
35836 Py_INCREF(Py_None); resultobj = Py_None;
35837 return resultobj;
35838 fail:
35839 return NULL;
35840 }
35841
35842
35843 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35844 PyObject *obj;
35845 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35846 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35847 Py_INCREF(obj);
35848 return Py_BuildValue((char *)"");
35849 }
35850 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35851 PyObject *resultobj;
35852 wxMenu *arg1 = (wxMenu *) NULL ;
35853 int arg2 = (int) wxID_ANY ;
35854 wxString const &arg3_defvalue = wxPyEmptyString ;
35855 wxString *arg3 = (wxString *) &arg3_defvalue ;
35856 wxString const &arg4_defvalue = wxPyEmptyString ;
35857 wxString *arg4 = (wxString *) &arg4_defvalue ;
35858 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35859 wxMenu *arg6 = (wxMenu *) NULL ;
35860 wxMenuItem *result;
35861 bool temp3 = false ;
35862 bool temp4 = false ;
35863 PyObject * obj0 = 0 ;
35864 PyObject * obj1 = 0 ;
35865 PyObject * obj2 = 0 ;
35866 PyObject * obj3 = 0 ;
35867 PyObject * obj4 = 0 ;
35868 PyObject * obj5 = 0 ;
35869 char *kwnames[] = {
35870 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35871 };
35872
35873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35874 if (obj0) {
35875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35876 if (SWIG_arg_fail(1)) SWIG_fail;
35877 }
35878 if (obj1) {
35879 {
35880 arg2 = (int)(SWIG_As_int(obj1));
35881 if (SWIG_arg_fail(2)) SWIG_fail;
35882 }
35883 }
35884 if (obj2) {
35885 {
35886 arg3 = wxString_in_helper(obj2);
35887 if (arg3 == NULL) SWIG_fail;
35888 temp3 = true;
35889 }
35890 }
35891 if (obj3) {
35892 {
35893 arg4 = wxString_in_helper(obj3);
35894 if (arg4 == NULL) SWIG_fail;
35895 temp4 = true;
35896 }
35897 }
35898 if (obj4) {
35899 {
35900 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35901 if (SWIG_arg_fail(5)) SWIG_fail;
35902 }
35903 }
35904 if (obj5) {
35905 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35906 if (SWIG_arg_fail(6)) SWIG_fail;
35907 }
35908 {
35909 PyThreadState* __tstate = wxPyBeginAllowThreads();
35910 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35911
35912 wxPyEndAllowThreads(__tstate);
35913 if (PyErr_Occurred()) SWIG_fail;
35914 }
35915 {
35916 resultobj = wxPyMake_wxObject(result, 1);
35917 }
35918 {
35919 if (temp3)
35920 delete arg3;
35921 }
35922 {
35923 if (temp4)
35924 delete arg4;
35925 }
35926 return resultobj;
35927 fail:
35928 {
35929 if (temp3)
35930 delete arg3;
35931 }
35932 {
35933 if (temp4)
35934 delete arg4;
35935 }
35936 return NULL;
35937 }
35938
35939
35940 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35941 PyObject *resultobj;
35942 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35943 wxMenu *result;
35944 PyObject * obj0 = 0 ;
35945 char *kwnames[] = {
35946 (char *) "self", NULL
35947 };
35948
35949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35951 if (SWIG_arg_fail(1)) SWIG_fail;
35952 {
35953 PyThreadState* __tstate = wxPyBeginAllowThreads();
35954 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35955
35956 wxPyEndAllowThreads(__tstate);
35957 if (PyErr_Occurred()) SWIG_fail;
35958 }
35959 {
35960 resultobj = wxPyMake_wxObject(result, 0);
35961 }
35962 return resultobj;
35963 fail:
35964 return NULL;
35965 }
35966
35967
35968 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35969 PyObject *resultobj;
35970 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35971 wxMenu *arg2 = (wxMenu *) 0 ;
35972 PyObject * obj0 = 0 ;
35973 PyObject * obj1 = 0 ;
35974 char *kwnames[] = {
35975 (char *) "self",(char *) "menu", NULL
35976 };
35977
35978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35980 if (SWIG_arg_fail(1)) SWIG_fail;
35981 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35982 if (SWIG_arg_fail(2)) SWIG_fail;
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 (arg1)->SetMenu(arg2);
35986
35987 wxPyEndAllowThreads(__tstate);
35988 if (PyErr_Occurred()) SWIG_fail;
35989 }
35990 Py_INCREF(Py_None); resultobj = Py_None;
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35998 PyObject *resultobj;
35999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36000 int arg2 ;
36001 PyObject * obj0 = 0 ;
36002 PyObject * obj1 = 0 ;
36003 char *kwnames[] = {
36004 (char *) "self",(char *) "id", NULL
36005 };
36006
36007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36009 if (SWIG_arg_fail(1)) SWIG_fail;
36010 {
36011 arg2 = (int)(SWIG_As_int(obj1));
36012 if (SWIG_arg_fail(2)) SWIG_fail;
36013 }
36014 {
36015 PyThreadState* __tstate = wxPyBeginAllowThreads();
36016 (arg1)->SetId(arg2);
36017
36018 wxPyEndAllowThreads(__tstate);
36019 if (PyErr_Occurred()) SWIG_fail;
36020 }
36021 Py_INCREF(Py_None); resultobj = Py_None;
36022 return resultobj;
36023 fail:
36024 return NULL;
36025 }
36026
36027
36028 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36029 PyObject *resultobj;
36030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36031 int result;
36032 PyObject * obj0 = 0 ;
36033 char *kwnames[] = {
36034 (char *) "self", NULL
36035 };
36036
36037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36039 if (SWIG_arg_fail(1)) SWIG_fail;
36040 {
36041 PyThreadState* __tstate = wxPyBeginAllowThreads();
36042 result = (int)((wxMenuItem const *)arg1)->GetId();
36043
36044 wxPyEndAllowThreads(__tstate);
36045 if (PyErr_Occurred()) SWIG_fail;
36046 }
36047 {
36048 resultobj = SWIG_From_int((int)(result));
36049 }
36050 return resultobj;
36051 fail:
36052 return NULL;
36053 }
36054
36055
36056 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36057 PyObject *resultobj;
36058 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36059 bool result;
36060 PyObject * obj0 = 0 ;
36061 char *kwnames[] = {
36062 (char *) "self", NULL
36063 };
36064
36065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36067 if (SWIG_arg_fail(1)) SWIG_fail;
36068 {
36069 PyThreadState* __tstate = wxPyBeginAllowThreads();
36070 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36071
36072 wxPyEndAllowThreads(__tstate);
36073 if (PyErr_Occurred()) SWIG_fail;
36074 }
36075 {
36076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36077 }
36078 return resultobj;
36079 fail:
36080 return NULL;
36081 }
36082
36083
36084 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36085 PyObject *resultobj;
36086 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36087 wxString *arg2 = 0 ;
36088 bool temp2 = false ;
36089 PyObject * obj0 = 0 ;
36090 PyObject * obj1 = 0 ;
36091 char *kwnames[] = {
36092 (char *) "self",(char *) "str", NULL
36093 };
36094
36095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36097 if (SWIG_arg_fail(1)) SWIG_fail;
36098 {
36099 arg2 = wxString_in_helper(obj1);
36100 if (arg2 == NULL) SWIG_fail;
36101 temp2 = true;
36102 }
36103 {
36104 PyThreadState* __tstate = wxPyBeginAllowThreads();
36105 (arg1)->SetText((wxString const &)*arg2);
36106
36107 wxPyEndAllowThreads(__tstate);
36108 if (PyErr_Occurred()) SWIG_fail;
36109 }
36110 Py_INCREF(Py_None); resultobj = Py_None;
36111 {
36112 if (temp2)
36113 delete arg2;
36114 }
36115 return resultobj;
36116 fail:
36117 {
36118 if (temp2)
36119 delete arg2;
36120 }
36121 return NULL;
36122 }
36123
36124
36125 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36126 PyObject *resultobj;
36127 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36128 wxString result;
36129 PyObject * obj0 = 0 ;
36130 char *kwnames[] = {
36131 (char *) "self", NULL
36132 };
36133
36134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36136 if (SWIG_arg_fail(1)) SWIG_fail;
36137 {
36138 PyThreadState* __tstate = wxPyBeginAllowThreads();
36139 result = ((wxMenuItem const *)arg1)->GetLabel();
36140
36141 wxPyEndAllowThreads(__tstate);
36142 if (PyErr_Occurred()) SWIG_fail;
36143 }
36144 {
36145 #if wxUSE_UNICODE
36146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36147 #else
36148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36149 #endif
36150 }
36151 return resultobj;
36152 fail:
36153 return NULL;
36154 }
36155
36156
36157 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36158 PyObject *resultobj;
36159 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36160 wxString *result;
36161 PyObject * obj0 = 0 ;
36162 char *kwnames[] = {
36163 (char *) "self", NULL
36164 };
36165
36166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36168 if (SWIG_arg_fail(1)) SWIG_fail;
36169 {
36170 PyThreadState* __tstate = wxPyBeginAllowThreads();
36171 {
36172 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36173 result = (wxString *) &_result_ref;
36174 }
36175
36176 wxPyEndAllowThreads(__tstate);
36177 if (PyErr_Occurred()) SWIG_fail;
36178 }
36179 {
36180 #if wxUSE_UNICODE
36181 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36182 #else
36183 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36184 #endif
36185 }
36186 return resultobj;
36187 fail:
36188 return NULL;
36189 }
36190
36191
36192 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36193 PyObject *resultobj;
36194 wxString *arg1 = 0 ;
36195 wxString result;
36196 bool temp1 = false ;
36197 PyObject * obj0 = 0 ;
36198 char *kwnames[] = {
36199 (char *) "text", NULL
36200 };
36201
36202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36203 {
36204 arg1 = wxString_in_helper(obj0);
36205 if (arg1 == NULL) SWIG_fail;
36206 temp1 = true;
36207 }
36208 {
36209 PyThreadState* __tstate = wxPyBeginAllowThreads();
36210 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36211
36212 wxPyEndAllowThreads(__tstate);
36213 if (PyErr_Occurred()) SWIG_fail;
36214 }
36215 {
36216 #if wxUSE_UNICODE
36217 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36218 #else
36219 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36220 #endif
36221 }
36222 {
36223 if (temp1)
36224 delete arg1;
36225 }
36226 return resultobj;
36227 fail:
36228 {
36229 if (temp1)
36230 delete arg1;
36231 }
36232 return NULL;
36233 }
36234
36235
36236 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36237 PyObject *resultobj;
36238 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36239 wxItemKind result;
36240 PyObject * obj0 = 0 ;
36241 char *kwnames[] = {
36242 (char *) "self", NULL
36243 };
36244
36245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36247 if (SWIG_arg_fail(1)) SWIG_fail;
36248 {
36249 PyThreadState* __tstate = wxPyBeginAllowThreads();
36250 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36251
36252 wxPyEndAllowThreads(__tstate);
36253 if (PyErr_Occurred()) SWIG_fail;
36254 }
36255 resultobj = SWIG_From_int((result));
36256 return resultobj;
36257 fail:
36258 return NULL;
36259 }
36260
36261
36262 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36263 PyObject *resultobj;
36264 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36265 wxItemKind arg2 ;
36266 PyObject * obj0 = 0 ;
36267 PyObject * obj1 = 0 ;
36268 char *kwnames[] = {
36269 (char *) "self",(char *) "kind", NULL
36270 };
36271
36272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36274 if (SWIG_arg_fail(1)) SWIG_fail;
36275 {
36276 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36277 if (SWIG_arg_fail(2)) SWIG_fail;
36278 }
36279 {
36280 PyThreadState* __tstate = wxPyBeginAllowThreads();
36281 (arg1)->SetKind((wxItemKind )arg2);
36282
36283 wxPyEndAllowThreads(__tstate);
36284 if (PyErr_Occurred()) SWIG_fail;
36285 }
36286 Py_INCREF(Py_None); resultobj = Py_None;
36287 return resultobj;
36288 fail:
36289 return NULL;
36290 }
36291
36292
36293 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36294 PyObject *resultobj;
36295 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36296 bool arg2 ;
36297 PyObject * obj0 = 0 ;
36298 PyObject * obj1 = 0 ;
36299 char *kwnames[] = {
36300 (char *) "self",(char *) "checkable", NULL
36301 };
36302
36303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36305 if (SWIG_arg_fail(1)) SWIG_fail;
36306 {
36307 arg2 = (bool)(SWIG_As_bool(obj1));
36308 if (SWIG_arg_fail(2)) SWIG_fail;
36309 }
36310 {
36311 PyThreadState* __tstate = wxPyBeginAllowThreads();
36312 (arg1)->SetCheckable(arg2);
36313
36314 wxPyEndAllowThreads(__tstate);
36315 if (PyErr_Occurred()) SWIG_fail;
36316 }
36317 Py_INCREF(Py_None); resultobj = Py_None;
36318 return resultobj;
36319 fail:
36320 return NULL;
36321 }
36322
36323
36324 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36325 PyObject *resultobj;
36326 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36327 bool result;
36328 PyObject * obj0 = 0 ;
36329 char *kwnames[] = {
36330 (char *) "self", NULL
36331 };
36332
36333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36335 if (SWIG_arg_fail(1)) SWIG_fail;
36336 {
36337 PyThreadState* __tstate = wxPyBeginAllowThreads();
36338 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36339
36340 wxPyEndAllowThreads(__tstate);
36341 if (PyErr_Occurred()) SWIG_fail;
36342 }
36343 {
36344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36345 }
36346 return resultobj;
36347 fail:
36348 return NULL;
36349 }
36350
36351
36352 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36353 PyObject *resultobj;
36354 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36355 bool result;
36356 PyObject * obj0 = 0 ;
36357 char *kwnames[] = {
36358 (char *) "self", NULL
36359 };
36360
36361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36363 if (SWIG_arg_fail(1)) SWIG_fail;
36364 {
36365 PyThreadState* __tstate = wxPyBeginAllowThreads();
36366 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36367
36368 wxPyEndAllowThreads(__tstate);
36369 if (PyErr_Occurred()) SWIG_fail;
36370 }
36371 {
36372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36373 }
36374 return resultobj;
36375 fail:
36376 return NULL;
36377 }
36378
36379
36380 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36381 PyObject *resultobj;
36382 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36383 wxMenu *arg2 = (wxMenu *) 0 ;
36384 PyObject * obj0 = 0 ;
36385 PyObject * obj1 = 0 ;
36386 char *kwnames[] = {
36387 (char *) "self",(char *) "menu", NULL
36388 };
36389
36390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36392 if (SWIG_arg_fail(1)) SWIG_fail;
36393 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36394 if (SWIG_arg_fail(2)) SWIG_fail;
36395 {
36396 PyThreadState* __tstate = wxPyBeginAllowThreads();
36397 (arg1)->SetSubMenu(arg2);
36398
36399 wxPyEndAllowThreads(__tstate);
36400 if (PyErr_Occurred()) SWIG_fail;
36401 }
36402 Py_INCREF(Py_None); resultobj = Py_None;
36403 return resultobj;
36404 fail:
36405 return NULL;
36406 }
36407
36408
36409 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36410 PyObject *resultobj;
36411 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36412 wxMenu *result;
36413 PyObject * obj0 = 0 ;
36414 char *kwnames[] = {
36415 (char *) "self", NULL
36416 };
36417
36418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36420 if (SWIG_arg_fail(1)) SWIG_fail;
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36424
36425 wxPyEndAllowThreads(__tstate);
36426 if (PyErr_Occurred()) SWIG_fail;
36427 }
36428 {
36429 resultobj = wxPyMake_wxObject(result, 0);
36430 }
36431 return resultobj;
36432 fail:
36433 return NULL;
36434 }
36435
36436
36437 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36438 PyObject *resultobj;
36439 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36440 bool arg2 = (bool) true ;
36441 PyObject * obj0 = 0 ;
36442 PyObject * obj1 = 0 ;
36443 char *kwnames[] = {
36444 (char *) "self",(char *) "enable", NULL
36445 };
36446
36447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36449 if (SWIG_arg_fail(1)) SWIG_fail;
36450 if (obj1) {
36451 {
36452 arg2 = (bool)(SWIG_As_bool(obj1));
36453 if (SWIG_arg_fail(2)) SWIG_fail;
36454 }
36455 }
36456 {
36457 PyThreadState* __tstate = wxPyBeginAllowThreads();
36458 (arg1)->Enable(arg2);
36459
36460 wxPyEndAllowThreads(__tstate);
36461 if (PyErr_Occurred()) SWIG_fail;
36462 }
36463 Py_INCREF(Py_None); resultobj = Py_None;
36464 return resultobj;
36465 fail:
36466 return NULL;
36467 }
36468
36469
36470 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36471 PyObject *resultobj;
36472 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36473 bool result;
36474 PyObject * obj0 = 0 ;
36475 char *kwnames[] = {
36476 (char *) "self", NULL
36477 };
36478
36479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36481 if (SWIG_arg_fail(1)) SWIG_fail;
36482 {
36483 PyThreadState* __tstate = wxPyBeginAllowThreads();
36484 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36485
36486 wxPyEndAllowThreads(__tstate);
36487 if (PyErr_Occurred()) SWIG_fail;
36488 }
36489 {
36490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36491 }
36492 return resultobj;
36493 fail:
36494 return NULL;
36495 }
36496
36497
36498 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36499 PyObject *resultobj;
36500 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36501 bool arg2 = (bool) true ;
36502 PyObject * obj0 = 0 ;
36503 PyObject * obj1 = 0 ;
36504 char *kwnames[] = {
36505 (char *) "self",(char *) "check", NULL
36506 };
36507
36508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36510 if (SWIG_arg_fail(1)) SWIG_fail;
36511 if (obj1) {
36512 {
36513 arg2 = (bool)(SWIG_As_bool(obj1));
36514 if (SWIG_arg_fail(2)) SWIG_fail;
36515 }
36516 }
36517 {
36518 PyThreadState* __tstate = wxPyBeginAllowThreads();
36519 (arg1)->Check(arg2);
36520
36521 wxPyEndAllowThreads(__tstate);
36522 if (PyErr_Occurred()) SWIG_fail;
36523 }
36524 Py_INCREF(Py_None); resultobj = Py_None;
36525 return resultobj;
36526 fail:
36527 return NULL;
36528 }
36529
36530
36531 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36532 PyObject *resultobj;
36533 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36534 bool result;
36535 PyObject * obj0 = 0 ;
36536 char *kwnames[] = {
36537 (char *) "self", NULL
36538 };
36539
36540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36542 if (SWIG_arg_fail(1)) SWIG_fail;
36543 {
36544 PyThreadState* __tstate = wxPyBeginAllowThreads();
36545 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36546
36547 wxPyEndAllowThreads(__tstate);
36548 if (PyErr_Occurred()) SWIG_fail;
36549 }
36550 {
36551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36552 }
36553 return resultobj;
36554 fail:
36555 return NULL;
36556 }
36557
36558
36559 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36560 PyObject *resultobj;
36561 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36562 PyObject * obj0 = 0 ;
36563 char *kwnames[] = {
36564 (char *) "self", NULL
36565 };
36566
36567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36569 if (SWIG_arg_fail(1)) SWIG_fail;
36570 {
36571 PyThreadState* __tstate = wxPyBeginAllowThreads();
36572 (arg1)->Toggle();
36573
36574 wxPyEndAllowThreads(__tstate);
36575 if (PyErr_Occurred()) SWIG_fail;
36576 }
36577 Py_INCREF(Py_None); resultobj = Py_None;
36578 return resultobj;
36579 fail:
36580 return NULL;
36581 }
36582
36583
36584 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36585 PyObject *resultobj;
36586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36587 wxString *arg2 = 0 ;
36588 bool temp2 = false ;
36589 PyObject * obj0 = 0 ;
36590 PyObject * obj1 = 0 ;
36591 char *kwnames[] = {
36592 (char *) "self",(char *) "str", NULL
36593 };
36594
36595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36597 if (SWIG_arg_fail(1)) SWIG_fail;
36598 {
36599 arg2 = wxString_in_helper(obj1);
36600 if (arg2 == NULL) SWIG_fail;
36601 temp2 = true;
36602 }
36603 {
36604 PyThreadState* __tstate = wxPyBeginAllowThreads();
36605 (arg1)->SetHelp((wxString const &)*arg2);
36606
36607 wxPyEndAllowThreads(__tstate);
36608 if (PyErr_Occurred()) SWIG_fail;
36609 }
36610 Py_INCREF(Py_None); resultobj = Py_None;
36611 {
36612 if (temp2)
36613 delete arg2;
36614 }
36615 return resultobj;
36616 fail:
36617 {
36618 if (temp2)
36619 delete arg2;
36620 }
36621 return NULL;
36622 }
36623
36624
36625 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36626 PyObject *resultobj;
36627 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36628 wxString *result;
36629 PyObject * obj0 = 0 ;
36630 char *kwnames[] = {
36631 (char *) "self", NULL
36632 };
36633
36634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36636 if (SWIG_arg_fail(1)) SWIG_fail;
36637 {
36638 PyThreadState* __tstate = wxPyBeginAllowThreads();
36639 {
36640 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36641 result = (wxString *) &_result_ref;
36642 }
36643
36644 wxPyEndAllowThreads(__tstate);
36645 if (PyErr_Occurred()) SWIG_fail;
36646 }
36647 {
36648 #if wxUSE_UNICODE
36649 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36650 #else
36651 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36652 #endif
36653 }
36654 return resultobj;
36655 fail:
36656 return NULL;
36657 }
36658
36659
36660 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36661 PyObject *resultobj;
36662 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36663 wxAcceleratorEntry *result;
36664 PyObject * obj0 = 0 ;
36665 char *kwnames[] = {
36666 (char *) "self", NULL
36667 };
36668
36669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36671 if (SWIG_arg_fail(1)) SWIG_fail;
36672 {
36673 PyThreadState* __tstate = wxPyBeginAllowThreads();
36674 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36675
36676 wxPyEndAllowThreads(__tstate);
36677 if (PyErr_Occurred()) SWIG_fail;
36678 }
36679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36680 return resultobj;
36681 fail:
36682 return NULL;
36683 }
36684
36685
36686 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36687 PyObject *resultobj;
36688 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36689 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36690 PyObject * obj0 = 0 ;
36691 PyObject * obj1 = 0 ;
36692 char *kwnames[] = {
36693 (char *) "self",(char *) "accel", NULL
36694 };
36695
36696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36698 if (SWIG_arg_fail(1)) SWIG_fail;
36699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36700 if (SWIG_arg_fail(2)) SWIG_fail;
36701 {
36702 PyThreadState* __tstate = wxPyBeginAllowThreads();
36703 (arg1)->SetAccel(arg2);
36704
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 Py_INCREF(Py_None); resultobj = Py_None;
36709 return resultobj;
36710 fail:
36711 return NULL;
36712 }
36713
36714
36715 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36716 PyObject *resultobj;
36717 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36718 wxFont *arg2 = 0 ;
36719 PyObject * obj0 = 0 ;
36720 PyObject * obj1 = 0 ;
36721 char *kwnames[] = {
36722 (char *) "self",(char *) "font", NULL
36723 };
36724
36725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36727 if (SWIG_arg_fail(1)) SWIG_fail;
36728 {
36729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36730 if (SWIG_arg_fail(2)) SWIG_fail;
36731 if (arg2 == NULL) {
36732 SWIG_null_ref("wxFont");
36733 }
36734 if (SWIG_arg_fail(2)) SWIG_fail;
36735 }
36736 {
36737 PyThreadState* __tstate = wxPyBeginAllowThreads();
36738 (arg1)->SetFont((wxFont const &)*arg2);
36739
36740 wxPyEndAllowThreads(__tstate);
36741 if (PyErr_Occurred()) SWIG_fail;
36742 }
36743 Py_INCREF(Py_None); resultobj = Py_None;
36744 return resultobj;
36745 fail:
36746 return NULL;
36747 }
36748
36749
36750 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36751 PyObject *resultobj;
36752 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36753 wxFont result;
36754 PyObject * obj0 = 0 ;
36755 char *kwnames[] = {
36756 (char *) "self", NULL
36757 };
36758
36759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36761 if (SWIG_arg_fail(1)) SWIG_fail;
36762 {
36763 PyThreadState* __tstate = wxPyBeginAllowThreads();
36764 result = (arg1)->GetFont();
36765
36766 wxPyEndAllowThreads(__tstate);
36767 if (PyErr_Occurred()) SWIG_fail;
36768 }
36769 {
36770 wxFont * resultptr;
36771 resultptr = new wxFont((wxFont &)(result));
36772 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36773 }
36774 return resultobj;
36775 fail:
36776 return NULL;
36777 }
36778
36779
36780 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36781 PyObject *resultobj;
36782 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36783 wxColour *arg2 = 0 ;
36784 wxColour temp2 ;
36785 PyObject * obj0 = 0 ;
36786 PyObject * obj1 = 0 ;
36787 char *kwnames[] = {
36788 (char *) "self",(char *) "colText", NULL
36789 };
36790
36791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36793 if (SWIG_arg_fail(1)) SWIG_fail;
36794 {
36795 arg2 = &temp2;
36796 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36797 }
36798 {
36799 PyThreadState* __tstate = wxPyBeginAllowThreads();
36800 (arg1)->SetTextColour((wxColour const &)*arg2);
36801
36802 wxPyEndAllowThreads(__tstate);
36803 if (PyErr_Occurred()) SWIG_fail;
36804 }
36805 Py_INCREF(Py_None); resultobj = Py_None;
36806 return resultobj;
36807 fail:
36808 return NULL;
36809 }
36810
36811
36812 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36813 PyObject *resultobj;
36814 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36815 wxColour result;
36816 PyObject * obj0 = 0 ;
36817 char *kwnames[] = {
36818 (char *) "self", NULL
36819 };
36820
36821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36823 if (SWIG_arg_fail(1)) SWIG_fail;
36824 {
36825 PyThreadState* __tstate = wxPyBeginAllowThreads();
36826 result = (arg1)->GetTextColour();
36827
36828 wxPyEndAllowThreads(__tstate);
36829 if (PyErr_Occurred()) SWIG_fail;
36830 }
36831 {
36832 wxColour * resultptr;
36833 resultptr = new wxColour((wxColour &)(result));
36834 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36835 }
36836 return resultobj;
36837 fail:
36838 return NULL;
36839 }
36840
36841
36842 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36843 PyObject *resultobj;
36844 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36845 wxColour *arg2 = 0 ;
36846 wxColour temp2 ;
36847 PyObject * obj0 = 0 ;
36848 PyObject * obj1 = 0 ;
36849 char *kwnames[] = {
36850 (char *) "self",(char *) "colBack", NULL
36851 };
36852
36853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36855 if (SWIG_arg_fail(1)) SWIG_fail;
36856 {
36857 arg2 = &temp2;
36858 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36859 }
36860 {
36861 PyThreadState* __tstate = wxPyBeginAllowThreads();
36862 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36863
36864 wxPyEndAllowThreads(__tstate);
36865 if (PyErr_Occurred()) SWIG_fail;
36866 }
36867 Py_INCREF(Py_None); resultobj = Py_None;
36868 return resultobj;
36869 fail:
36870 return NULL;
36871 }
36872
36873
36874 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36875 PyObject *resultobj;
36876 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36877 wxColour result;
36878 PyObject * obj0 = 0 ;
36879 char *kwnames[] = {
36880 (char *) "self", NULL
36881 };
36882
36883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36885 if (SWIG_arg_fail(1)) SWIG_fail;
36886 {
36887 PyThreadState* __tstate = wxPyBeginAllowThreads();
36888 result = (arg1)->GetBackgroundColour();
36889
36890 wxPyEndAllowThreads(__tstate);
36891 if (PyErr_Occurred()) SWIG_fail;
36892 }
36893 {
36894 wxColour * resultptr;
36895 resultptr = new wxColour((wxColour &)(result));
36896 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36897 }
36898 return resultobj;
36899 fail:
36900 return NULL;
36901 }
36902
36903
36904 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36905 PyObject *resultobj;
36906 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36907 wxBitmap *arg2 = 0 ;
36908 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36909 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36910 PyObject * obj0 = 0 ;
36911 PyObject * obj1 = 0 ;
36912 PyObject * obj2 = 0 ;
36913 char *kwnames[] = {
36914 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36915 };
36916
36917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36919 if (SWIG_arg_fail(1)) SWIG_fail;
36920 {
36921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36922 if (SWIG_arg_fail(2)) SWIG_fail;
36923 if (arg2 == NULL) {
36924 SWIG_null_ref("wxBitmap");
36925 }
36926 if (SWIG_arg_fail(2)) SWIG_fail;
36927 }
36928 if (obj2) {
36929 {
36930 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36931 if (SWIG_arg_fail(3)) SWIG_fail;
36932 if (arg3 == NULL) {
36933 SWIG_null_ref("wxBitmap");
36934 }
36935 if (SWIG_arg_fail(3)) SWIG_fail;
36936 }
36937 }
36938 {
36939 PyThreadState* __tstate = wxPyBeginAllowThreads();
36940 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36941
36942 wxPyEndAllowThreads(__tstate);
36943 if (PyErr_Occurred()) SWIG_fail;
36944 }
36945 Py_INCREF(Py_None); resultobj = Py_None;
36946 return resultobj;
36947 fail:
36948 return NULL;
36949 }
36950
36951
36952 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36953 PyObject *resultobj;
36954 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36955 wxBitmap *arg2 = 0 ;
36956 PyObject * obj0 = 0 ;
36957 PyObject * obj1 = 0 ;
36958 char *kwnames[] = {
36959 (char *) "self",(char *) "bmpDisabled", NULL
36960 };
36961
36962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36964 if (SWIG_arg_fail(1)) SWIG_fail;
36965 {
36966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36967 if (SWIG_arg_fail(2)) SWIG_fail;
36968 if (arg2 == NULL) {
36969 SWIG_null_ref("wxBitmap");
36970 }
36971 if (SWIG_arg_fail(2)) SWIG_fail;
36972 }
36973 {
36974 PyThreadState* __tstate = wxPyBeginAllowThreads();
36975 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36976
36977 wxPyEndAllowThreads(__tstate);
36978 if (PyErr_Occurred()) SWIG_fail;
36979 }
36980 Py_INCREF(Py_None); resultobj = Py_None;
36981 return resultobj;
36982 fail:
36983 return NULL;
36984 }
36985
36986
36987 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36988 PyObject *resultobj;
36989 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36990 wxBitmap *result;
36991 PyObject * obj0 = 0 ;
36992 char *kwnames[] = {
36993 (char *) "self", NULL
36994 };
36995
36996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36998 if (SWIG_arg_fail(1)) SWIG_fail;
36999 {
37000 PyThreadState* __tstate = wxPyBeginAllowThreads();
37001 {
37002 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
37003 result = (wxBitmap *) &_result_ref;
37004 }
37005
37006 wxPyEndAllowThreads(__tstate);
37007 if (PyErr_Occurred()) SWIG_fail;
37008 }
37009 {
37010 wxBitmap* resultptr = new wxBitmap(*result);
37011 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37012 }
37013 return resultobj;
37014 fail:
37015 return NULL;
37016 }
37017
37018
37019 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37020 PyObject *resultobj;
37021 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37022 int arg2 ;
37023 PyObject * obj0 = 0 ;
37024 PyObject * obj1 = 0 ;
37025 char *kwnames[] = {
37026 (char *) "self",(char *) "nWidth", NULL
37027 };
37028
37029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37031 if (SWIG_arg_fail(1)) SWIG_fail;
37032 {
37033 arg2 = (int)(SWIG_As_int(obj1));
37034 if (SWIG_arg_fail(2)) SWIG_fail;
37035 }
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 (arg1)->SetMarginWidth(arg2);
37039
37040 wxPyEndAllowThreads(__tstate);
37041 if (PyErr_Occurred()) SWIG_fail;
37042 }
37043 Py_INCREF(Py_None); resultobj = Py_None;
37044 return resultobj;
37045 fail:
37046 return NULL;
37047 }
37048
37049
37050 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37051 PyObject *resultobj;
37052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37053 int result;
37054 PyObject * obj0 = 0 ;
37055 char *kwnames[] = {
37056 (char *) "self", NULL
37057 };
37058
37059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37061 if (SWIG_arg_fail(1)) SWIG_fail;
37062 {
37063 PyThreadState* __tstate = wxPyBeginAllowThreads();
37064 result = (int)(arg1)->GetMarginWidth();
37065
37066 wxPyEndAllowThreads(__tstate);
37067 if (PyErr_Occurred()) SWIG_fail;
37068 }
37069 {
37070 resultobj = SWIG_From_int((int)(result));
37071 }
37072 return resultobj;
37073 fail:
37074 return NULL;
37075 }
37076
37077
37078 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37079 PyObject *resultobj;
37080 int result;
37081 char *kwnames[] = {
37082 NULL
37083 };
37084
37085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37086 {
37087 PyThreadState* __tstate = wxPyBeginAllowThreads();
37088 result = (int)wxMenuItem::GetDefaultMarginWidth();
37089
37090 wxPyEndAllowThreads(__tstate);
37091 if (PyErr_Occurred()) SWIG_fail;
37092 }
37093 {
37094 resultobj = SWIG_From_int((int)(result));
37095 }
37096 return resultobj;
37097 fail:
37098 return NULL;
37099 }
37100
37101
37102 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37103 PyObject *resultobj;
37104 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37105 bool result;
37106 PyObject * obj0 = 0 ;
37107 char *kwnames[] = {
37108 (char *) "self", NULL
37109 };
37110
37111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37113 if (SWIG_arg_fail(1)) SWIG_fail;
37114 {
37115 PyThreadState* __tstate = wxPyBeginAllowThreads();
37116 result = (bool)(arg1)->IsOwnerDrawn();
37117
37118 wxPyEndAllowThreads(__tstate);
37119 if (PyErr_Occurred()) SWIG_fail;
37120 }
37121 {
37122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37123 }
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37131 PyObject *resultobj;
37132 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37133 bool arg2 = (bool) true ;
37134 PyObject * obj0 = 0 ;
37135 PyObject * obj1 = 0 ;
37136 char *kwnames[] = {
37137 (char *) "self",(char *) "ownerDrawn", NULL
37138 };
37139
37140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37142 if (SWIG_arg_fail(1)) SWIG_fail;
37143 if (obj1) {
37144 {
37145 arg2 = (bool)(SWIG_As_bool(obj1));
37146 if (SWIG_arg_fail(2)) SWIG_fail;
37147 }
37148 }
37149 {
37150 PyThreadState* __tstate = wxPyBeginAllowThreads();
37151 (arg1)->SetOwnerDrawn(arg2);
37152
37153 wxPyEndAllowThreads(__tstate);
37154 if (PyErr_Occurred()) SWIG_fail;
37155 }
37156 Py_INCREF(Py_None); resultobj = Py_None;
37157 return resultobj;
37158 fail:
37159 return NULL;
37160 }
37161
37162
37163 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37164 PyObject *resultobj;
37165 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37166 PyObject * obj0 = 0 ;
37167 char *kwnames[] = {
37168 (char *) "self", NULL
37169 };
37170
37171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37173 if (SWIG_arg_fail(1)) SWIG_fail;
37174 {
37175 PyThreadState* __tstate = wxPyBeginAllowThreads();
37176 (arg1)->ResetOwnerDrawn();
37177
37178 wxPyEndAllowThreads(__tstate);
37179 if (PyErr_Occurred()) SWIG_fail;
37180 }
37181 Py_INCREF(Py_None); resultobj = Py_None;
37182 return resultobj;
37183 fail:
37184 return NULL;
37185 }
37186
37187
37188 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37189 PyObject *resultobj;
37190 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37191 wxBitmap *arg2 = 0 ;
37192 PyObject * obj0 = 0 ;
37193 PyObject * obj1 = 0 ;
37194 char *kwnames[] = {
37195 (char *) "self",(char *) "bitmap", NULL
37196 };
37197
37198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37200 if (SWIG_arg_fail(1)) SWIG_fail;
37201 {
37202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37203 if (SWIG_arg_fail(2)) SWIG_fail;
37204 if (arg2 == NULL) {
37205 SWIG_null_ref("wxBitmap");
37206 }
37207 if (SWIG_arg_fail(2)) SWIG_fail;
37208 }
37209 {
37210 PyThreadState* __tstate = wxPyBeginAllowThreads();
37211 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37212
37213 wxPyEndAllowThreads(__tstate);
37214 if (PyErr_Occurred()) SWIG_fail;
37215 }
37216 Py_INCREF(Py_None); resultobj = Py_None;
37217 return resultobj;
37218 fail:
37219 return NULL;
37220 }
37221
37222
37223 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37224 PyObject *resultobj;
37225 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37226 wxBitmap *result;
37227 PyObject * obj0 = 0 ;
37228 char *kwnames[] = {
37229 (char *) "self", NULL
37230 };
37231
37232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37234 if (SWIG_arg_fail(1)) SWIG_fail;
37235 {
37236 PyThreadState* __tstate = wxPyBeginAllowThreads();
37237 {
37238 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37239 result = (wxBitmap *) &_result_ref;
37240 }
37241
37242 wxPyEndAllowThreads(__tstate);
37243 if (PyErr_Occurred()) SWIG_fail;
37244 }
37245 {
37246 wxBitmap* resultptr = new wxBitmap(*result);
37247 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37248 }
37249 return resultobj;
37250 fail:
37251 return NULL;
37252 }
37253
37254
37255 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37256 PyObject *obj;
37257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37258 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37259 Py_INCREF(obj);
37260 return Py_BuildValue((char *)"");
37261 }
37262 static int _wrap_ControlNameStr_set(PyObject *) {
37263 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37264 return 1;
37265 }
37266
37267
37268 static PyObject *_wrap_ControlNameStr_get(void) {
37269 PyObject *pyobj;
37270
37271 {
37272 #if wxUSE_UNICODE
37273 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37274 #else
37275 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37276 #endif
37277 }
37278 return pyobj;
37279 }
37280
37281
37282 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37283 PyObject *resultobj;
37284 wxWindow *arg1 = (wxWindow *) 0 ;
37285 int arg2 = (int) -1 ;
37286 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37287 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37288 wxSize const &arg4_defvalue = wxDefaultSize ;
37289 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37290 long arg5 = (long) 0 ;
37291 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37292 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37293 wxString const &arg7_defvalue = wxPyControlNameStr ;
37294 wxString *arg7 = (wxString *) &arg7_defvalue ;
37295 wxControl *result;
37296 wxPoint temp3 ;
37297 wxSize temp4 ;
37298 bool temp7 = false ;
37299 PyObject * obj0 = 0 ;
37300 PyObject * obj1 = 0 ;
37301 PyObject * obj2 = 0 ;
37302 PyObject * obj3 = 0 ;
37303 PyObject * obj4 = 0 ;
37304 PyObject * obj5 = 0 ;
37305 PyObject * obj6 = 0 ;
37306 char *kwnames[] = {
37307 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37308 };
37309
37310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37312 if (SWIG_arg_fail(1)) SWIG_fail;
37313 if (obj1) {
37314 {
37315 arg2 = (int)(SWIG_As_int(obj1));
37316 if (SWIG_arg_fail(2)) SWIG_fail;
37317 }
37318 }
37319 if (obj2) {
37320 {
37321 arg3 = &temp3;
37322 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37323 }
37324 }
37325 if (obj3) {
37326 {
37327 arg4 = &temp4;
37328 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37329 }
37330 }
37331 if (obj4) {
37332 {
37333 arg5 = (long)(SWIG_As_long(obj4));
37334 if (SWIG_arg_fail(5)) SWIG_fail;
37335 }
37336 }
37337 if (obj5) {
37338 {
37339 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37340 if (SWIG_arg_fail(6)) SWIG_fail;
37341 if (arg6 == NULL) {
37342 SWIG_null_ref("wxValidator");
37343 }
37344 if (SWIG_arg_fail(6)) SWIG_fail;
37345 }
37346 }
37347 if (obj6) {
37348 {
37349 arg7 = wxString_in_helper(obj6);
37350 if (arg7 == NULL) SWIG_fail;
37351 temp7 = true;
37352 }
37353 }
37354 {
37355 if (!wxPyCheckForApp()) SWIG_fail;
37356 PyThreadState* __tstate = wxPyBeginAllowThreads();
37357 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37358
37359 wxPyEndAllowThreads(__tstate);
37360 if (PyErr_Occurred()) SWIG_fail;
37361 }
37362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37363 {
37364 if (temp7)
37365 delete arg7;
37366 }
37367 return resultobj;
37368 fail:
37369 {
37370 if (temp7)
37371 delete arg7;
37372 }
37373 return NULL;
37374 }
37375
37376
37377 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37378 PyObject *resultobj;
37379 wxControl *result;
37380 char *kwnames[] = {
37381 NULL
37382 };
37383
37384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37385 {
37386 if (!wxPyCheckForApp()) SWIG_fail;
37387 PyThreadState* __tstate = wxPyBeginAllowThreads();
37388 result = (wxControl *)new wxControl();
37389
37390 wxPyEndAllowThreads(__tstate);
37391 if (PyErr_Occurred()) SWIG_fail;
37392 }
37393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37394 return resultobj;
37395 fail:
37396 return NULL;
37397 }
37398
37399
37400 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37401 PyObject *resultobj;
37402 wxControl *arg1 = (wxControl *) 0 ;
37403 wxWindow *arg2 = (wxWindow *) 0 ;
37404 int arg3 = (int) -1 ;
37405 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37406 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37407 wxSize const &arg5_defvalue = wxDefaultSize ;
37408 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37409 long arg6 = (long) 0 ;
37410 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37411 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37412 wxString const &arg8_defvalue = wxPyControlNameStr ;
37413 wxString *arg8 = (wxString *) &arg8_defvalue ;
37414 bool result;
37415 wxPoint temp4 ;
37416 wxSize temp5 ;
37417 bool temp8 = false ;
37418 PyObject * obj0 = 0 ;
37419 PyObject * obj1 = 0 ;
37420 PyObject * obj2 = 0 ;
37421 PyObject * obj3 = 0 ;
37422 PyObject * obj4 = 0 ;
37423 PyObject * obj5 = 0 ;
37424 PyObject * obj6 = 0 ;
37425 PyObject * obj7 = 0 ;
37426 char *kwnames[] = {
37427 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37428 };
37429
37430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37432 if (SWIG_arg_fail(1)) SWIG_fail;
37433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37434 if (SWIG_arg_fail(2)) SWIG_fail;
37435 if (obj2) {
37436 {
37437 arg3 = (int)(SWIG_As_int(obj2));
37438 if (SWIG_arg_fail(3)) SWIG_fail;
37439 }
37440 }
37441 if (obj3) {
37442 {
37443 arg4 = &temp4;
37444 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37445 }
37446 }
37447 if (obj4) {
37448 {
37449 arg5 = &temp5;
37450 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37451 }
37452 }
37453 if (obj5) {
37454 {
37455 arg6 = (long)(SWIG_As_long(obj5));
37456 if (SWIG_arg_fail(6)) SWIG_fail;
37457 }
37458 }
37459 if (obj6) {
37460 {
37461 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37462 if (SWIG_arg_fail(7)) SWIG_fail;
37463 if (arg7 == NULL) {
37464 SWIG_null_ref("wxValidator");
37465 }
37466 if (SWIG_arg_fail(7)) SWIG_fail;
37467 }
37468 }
37469 if (obj7) {
37470 {
37471 arg8 = wxString_in_helper(obj7);
37472 if (arg8 == NULL) SWIG_fail;
37473 temp8 = true;
37474 }
37475 }
37476 {
37477 PyThreadState* __tstate = wxPyBeginAllowThreads();
37478 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37479
37480 wxPyEndAllowThreads(__tstate);
37481 if (PyErr_Occurred()) SWIG_fail;
37482 }
37483 {
37484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37485 }
37486 {
37487 if (temp8)
37488 delete arg8;
37489 }
37490 return resultobj;
37491 fail:
37492 {
37493 if (temp8)
37494 delete arg8;
37495 }
37496 return NULL;
37497 }
37498
37499
37500 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37501 PyObject *resultobj;
37502 wxControl *arg1 = (wxControl *) 0 ;
37503 wxCommandEvent *arg2 = 0 ;
37504 PyObject * obj0 = 0 ;
37505 PyObject * obj1 = 0 ;
37506 char *kwnames[] = {
37507 (char *) "self",(char *) "event", NULL
37508 };
37509
37510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37512 if (SWIG_arg_fail(1)) SWIG_fail;
37513 {
37514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37515 if (SWIG_arg_fail(2)) SWIG_fail;
37516 if (arg2 == NULL) {
37517 SWIG_null_ref("wxCommandEvent");
37518 }
37519 if (SWIG_arg_fail(2)) SWIG_fail;
37520 }
37521 {
37522 PyThreadState* __tstate = wxPyBeginAllowThreads();
37523 (arg1)->Command(*arg2);
37524
37525 wxPyEndAllowThreads(__tstate);
37526 if (PyErr_Occurred()) SWIG_fail;
37527 }
37528 Py_INCREF(Py_None); resultobj = Py_None;
37529 return resultobj;
37530 fail:
37531 return NULL;
37532 }
37533
37534
37535 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37536 PyObject *resultobj;
37537 wxControl *arg1 = (wxControl *) 0 ;
37538 wxString result;
37539 PyObject * obj0 = 0 ;
37540 char *kwnames[] = {
37541 (char *) "self", NULL
37542 };
37543
37544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37546 if (SWIG_arg_fail(1)) SWIG_fail;
37547 {
37548 PyThreadState* __tstate = wxPyBeginAllowThreads();
37549 result = (arg1)->GetLabel();
37550
37551 wxPyEndAllowThreads(__tstate);
37552 if (PyErr_Occurred()) SWIG_fail;
37553 }
37554 {
37555 #if wxUSE_UNICODE
37556 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37557 #else
37558 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37559 #endif
37560 }
37561 return resultobj;
37562 fail:
37563 return NULL;
37564 }
37565
37566
37567 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37568 PyObject *resultobj;
37569 wxControl *arg1 = (wxControl *) 0 ;
37570 wxString *arg2 = 0 ;
37571 bool temp2 = false ;
37572 PyObject * obj0 = 0 ;
37573 PyObject * obj1 = 0 ;
37574 char *kwnames[] = {
37575 (char *) "self",(char *) "label", NULL
37576 };
37577
37578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37580 if (SWIG_arg_fail(1)) SWIG_fail;
37581 {
37582 arg2 = wxString_in_helper(obj1);
37583 if (arg2 == NULL) SWIG_fail;
37584 temp2 = true;
37585 }
37586 {
37587 PyThreadState* __tstate = wxPyBeginAllowThreads();
37588 (arg1)->SetLabel((wxString const &)*arg2);
37589
37590 wxPyEndAllowThreads(__tstate);
37591 if (PyErr_Occurred()) SWIG_fail;
37592 }
37593 Py_INCREF(Py_None); resultobj = Py_None;
37594 {
37595 if (temp2)
37596 delete arg2;
37597 }
37598 return resultobj;
37599 fail:
37600 {
37601 if (temp2)
37602 delete arg2;
37603 }
37604 return NULL;
37605 }
37606
37607
37608 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37609 PyObject *resultobj;
37610 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37611 wxVisualAttributes result;
37612 PyObject * obj0 = 0 ;
37613 char *kwnames[] = {
37614 (char *) "variant", NULL
37615 };
37616
37617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37618 if (obj0) {
37619 {
37620 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37621 if (SWIG_arg_fail(1)) SWIG_fail;
37622 }
37623 }
37624 {
37625 if (!wxPyCheckForApp()) SWIG_fail;
37626 PyThreadState* __tstate = wxPyBeginAllowThreads();
37627 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37628
37629 wxPyEndAllowThreads(__tstate);
37630 if (PyErr_Occurred()) SWIG_fail;
37631 }
37632 {
37633 wxVisualAttributes * resultptr;
37634 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37636 }
37637 return resultobj;
37638 fail:
37639 return NULL;
37640 }
37641
37642
37643 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37644 PyObject *obj;
37645 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37646 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37647 Py_INCREF(obj);
37648 return Py_BuildValue((char *)"");
37649 }
37650 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37651 PyObject *resultobj;
37652 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37653 wxString *arg2 = 0 ;
37654 PyObject *arg3 = (PyObject *) NULL ;
37655 int result;
37656 bool temp2 = false ;
37657 PyObject * obj0 = 0 ;
37658 PyObject * obj1 = 0 ;
37659 PyObject * obj2 = 0 ;
37660 char *kwnames[] = {
37661 (char *) "self",(char *) "item",(char *) "clientData", NULL
37662 };
37663
37664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37666 if (SWIG_arg_fail(1)) SWIG_fail;
37667 {
37668 arg2 = wxString_in_helper(obj1);
37669 if (arg2 == NULL) SWIG_fail;
37670 temp2 = true;
37671 }
37672 if (obj2) {
37673 arg3 = obj2;
37674 }
37675 {
37676 PyThreadState* __tstate = wxPyBeginAllowThreads();
37677 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37678
37679 wxPyEndAllowThreads(__tstate);
37680 if (PyErr_Occurred()) SWIG_fail;
37681 }
37682 {
37683 resultobj = SWIG_From_int((int)(result));
37684 }
37685 {
37686 if (temp2)
37687 delete arg2;
37688 }
37689 return resultobj;
37690 fail:
37691 {
37692 if (temp2)
37693 delete arg2;
37694 }
37695 return NULL;
37696 }
37697
37698
37699 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37700 PyObject *resultobj;
37701 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37702 wxArrayString *arg2 = 0 ;
37703 bool temp2 = false ;
37704 PyObject * obj0 = 0 ;
37705 PyObject * obj1 = 0 ;
37706 char *kwnames[] = {
37707 (char *) "self",(char *) "strings", NULL
37708 };
37709
37710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37712 if (SWIG_arg_fail(1)) SWIG_fail;
37713 {
37714 if (! PySequence_Check(obj1)) {
37715 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37716 SWIG_fail;
37717 }
37718 arg2 = new wxArrayString;
37719 temp2 = true;
37720 int i, len=PySequence_Length(obj1);
37721 for (i=0; i<len; i++) {
37722 PyObject* item = PySequence_GetItem(obj1, i);
37723 #if wxUSE_UNICODE
37724 PyObject* str = PyObject_Unicode(item);
37725 #else
37726 PyObject* str = PyObject_Str(item);
37727 #endif
37728 if (PyErr_Occurred()) SWIG_fail;
37729 arg2->Add(Py2wxString(str));
37730 Py_DECREF(item);
37731 Py_DECREF(str);
37732 }
37733 }
37734 {
37735 PyThreadState* __tstate = wxPyBeginAllowThreads();
37736 (arg1)->Append((wxArrayString const &)*arg2);
37737
37738 wxPyEndAllowThreads(__tstate);
37739 if (PyErr_Occurred()) SWIG_fail;
37740 }
37741 Py_INCREF(Py_None); resultobj = Py_None;
37742 {
37743 if (temp2) delete arg2;
37744 }
37745 return resultobj;
37746 fail:
37747 {
37748 if (temp2) delete arg2;
37749 }
37750 return NULL;
37751 }
37752
37753
37754 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37755 PyObject *resultobj;
37756 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37757 wxString *arg2 = 0 ;
37758 int arg3 ;
37759 PyObject *arg4 = (PyObject *) NULL ;
37760 int result;
37761 bool temp2 = false ;
37762 PyObject * obj0 = 0 ;
37763 PyObject * obj1 = 0 ;
37764 PyObject * obj2 = 0 ;
37765 PyObject * obj3 = 0 ;
37766 char *kwnames[] = {
37767 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37768 };
37769
37770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37772 if (SWIG_arg_fail(1)) SWIG_fail;
37773 {
37774 arg2 = wxString_in_helper(obj1);
37775 if (arg2 == NULL) SWIG_fail;
37776 temp2 = true;
37777 }
37778 {
37779 arg3 = (int)(SWIG_As_int(obj2));
37780 if (SWIG_arg_fail(3)) SWIG_fail;
37781 }
37782 if (obj3) {
37783 arg4 = obj3;
37784 }
37785 {
37786 PyThreadState* __tstate = wxPyBeginAllowThreads();
37787 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37788
37789 wxPyEndAllowThreads(__tstate);
37790 if (PyErr_Occurred()) SWIG_fail;
37791 }
37792 {
37793 resultobj = SWIG_From_int((int)(result));
37794 }
37795 {
37796 if (temp2)
37797 delete arg2;
37798 }
37799 return resultobj;
37800 fail:
37801 {
37802 if (temp2)
37803 delete arg2;
37804 }
37805 return NULL;
37806 }
37807
37808
37809 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37810 PyObject *resultobj;
37811 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37812 PyObject * obj0 = 0 ;
37813 char *kwnames[] = {
37814 (char *) "self", NULL
37815 };
37816
37817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37819 if (SWIG_arg_fail(1)) SWIG_fail;
37820 {
37821 PyThreadState* __tstate = wxPyBeginAllowThreads();
37822 (arg1)->Clear();
37823
37824 wxPyEndAllowThreads(__tstate);
37825 if (PyErr_Occurred()) SWIG_fail;
37826 }
37827 Py_INCREF(Py_None); resultobj = Py_None;
37828 return resultobj;
37829 fail:
37830 return NULL;
37831 }
37832
37833
37834 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37835 PyObject *resultobj;
37836 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37837 int arg2 ;
37838 PyObject * obj0 = 0 ;
37839 PyObject * obj1 = 0 ;
37840 char *kwnames[] = {
37841 (char *) "self",(char *) "n", NULL
37842 };
37843
37844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37846 if (SWIG_arg_fail(1)) SWIG_fail;
37847 {
37848 arg2 = (int)(SWIG_As_int(obj1));
37849 if (SWIG_arg_fail(2)) SWIG_fail;
37850 }
37851 {
37852 PyThreadState* __tstate = wxPyBeginAllowThreads();
37853 (arg1)->Delete(arg2);
37854
37855 wxPyEndAllowThreads(__tstate);
37856 if (PyErr_Occurred()) SWIG_fail;
37857 }
37858 Py_INCREF(Py_None); resultobj = Py_None;
37859 return resultobj;
37860 fail:
37861 return NULL;
37862 }
37863
37864
37865 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37866 PyObject *resultobj;
37867 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37868 int arg2 ;
37869 PyObject *result;
37870 PyObject * obj0 = 0 ;
37871 PyObject * obj1 = 0 ;
37872 char *kwnames[] = {
37873 (char *) "self",(char *) "n", NULL
37874 };
37875
37876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37878 if (SWIG_arg_fail(1)) SWIG_fail;
37879 {
37880 arg2 = (int)(SWIG_As_int(obj1));
37881 if (SWIG_arg_fail(2)) SWIG_fail;
37882 }
37883 {
37884 PyThreadState* __tstate = wxPyBeginAllowThreads();
37885 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37886
37887 wxPyEndAllowThreads(__tstate);
37888 if (PyErr_Occurred()) SWIG_fail;
37889 }
37890 resultobj = result;
37891 return resultobj;
37892 fail:
37893 return NULL;
37894 }
37895
37896
37897 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37898 PyObject *resultobj;
37899 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37900 int arg2 ;
37901 PyObject *arg3 = (PyObject *) 0 ;
37902 PyObject * obj0 = 0 ;
37903 PyObject * obj1 = 0 ;
37904 PyObject * obj2 = 0 ;
37905 char *kwnames[] = {
37906 (char *) "self",(char *) "n",(char *) "clientData", NULL
37907 };
37908
37909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37911 if (SWIG_arg_fail(1)) SWIG_fail;
37912 {
37913 arg2 = (int)(SWIG_As_int(obj1));
37914 if (SWIG_arg_fail(2)) SWIG_fail;
37915 }
37916 arg3 = obj2;
37917 {
37918 PyThreadState* __tstate = wxPyBeginAllowThreads();
37919 wxItemContainer_SetClientData(arg1,arg2,arg3);
37920
37921 wxPyEndAllowThreads(__tstate);
37922 if (PyErr_Occurred()) SWIG_fail;
37923 }
37924 Py_INCREF(Py_None); resultobj = Py_None;
37925 return resultobj;
37926 fail:
37927 return NULL;
37928 }
37929
37930
37931 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37932 PyObject *resultobj;
37933 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37934 int result;
37935 PyObject * obj0 = 0 ;
37936 char *kwnames[] = {
37937 (char *) "self", NULL
37938 };
37939
37940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37942 if (SWIG_arg_fail(1)) SWIG_fail;
37943 {
37944 PyThreadState* __tstate = wxPyBeginAllowThreads();
37945 result = (int)((wxItemContainer const *)arg1)->GetCount();
37946
37947 wxPyEndAllowThreads(__tstate);
37948 if (PyErr_Occurred()) SWIG_fail;
37949 }
37950 {
37951 resultobj = SWIG_From_int((int)(result));
37952 }
37953 return resultobj;
37954 fail:
37955 return NULL;
37956 }
37957
37958
37959 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37960 PyObject *resultobj;
37961 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37962 bool result;
37963 PyObject * obj0 = 0 ;
37964 char *kwnames[] = {
37965 (char *) "self", NULL
37966 };
37967
37968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37970 if (SWIG_arg_fail(1)) SWIG_fail;
37971 {
37972 PyThreadState* __tstate = wxPyBeginAllowThreads();
37973 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37974
37975 wxPyEndAllowThreads(__tstate);
37976 if (PyErr_Occurred()) SWIG_fail;
37977 }
37978 {
37979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37980 }
37981 return resultobj;
37982 fail:
37983 return NULL;
37984 }
37985
37986
37987 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37988 PyObject *resultobj;
37989 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37990 int arg2 ;
37991 wxString result;
37992 PyObject * obj0 = 0 ;
37993 PyObject * obj1 = 0 ;
37994 char *kwnames[] = {
37995 (char *) "self",(char *) "n", NULL
37996 };
37997
37998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38000 if (SWIG_arg_fail(1)) SWIG_fail;
38001 {
38002 arg2 = (int)(SWIG_As_int(obj1));
38003 if (SWIG_arg_fail(2)) SWIG_fail;
38004 }
38005 {
38006 PyThreadState* __tstate = wxPyBeginAllowThreads();
38007 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38008
38009 wxPyEndAllowThreads(__tstate);
38010 if (PyErr_Occurred()) SWIG_fail;
38011 }
38012 {
38013 #if wxUSE_UNICODE
38014 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38015 #else
38016 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38017 #endif
38018 }
38019 return resultobj;
38020 fail:
38021 return NULL;
38022 }
38023
38024
38025 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38026 PyObject *resultobj;
38027 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38028 wxArrayString result;
38029 PyObject * obj0 = 0 ;
38030 char *kwnames[] = {
38031 (char *) "self", NULL
38032 };
38033
38034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38036 if (SWIG_arg_fail(1)) SWIG_fail;
38037 {
38038 PyThreadState* __tstate = wxPyBeginAllowThreads();
38039 result = ((wxItemContainer const *)arg1)->GetStrings();
38040
38041 wxPyEndAllowThreads(__tstate);
38042 if (PyErr_Occurred()) SWIG_fail;
38043 }
38044 {
38045 resultobj = wxArrayString2PyList_helper(result);
38046 }
38047 return resultobj;
38048 fail:
38049 return NULL;
38050 }
38051
38052
38053 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38054 PyObject *resultobj;
38055 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38056 int arg2 ;
38057 wxString *arg3 = 0 ;
38058 bool temp3 = false ;
38059 PyObject * obj0 = 0 ;
38060 PyObject * obj1 = 0 ;
38061 PyObject * obj2 = 0 ;
38062 char *kwnames[] = {
38063 (char *) "self",(char *) "n",(char *) "s", NULL
38064 };
38065
38066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38068 if (SWIG_arg_fail(1)) SWIG_fail;
38069 {
38070 arg2 = (int)(SWIG_As_int(obj1));
38071 if (SWIG_arg_fail(2)) SWIG_fail;
38072 }
38073 {
38074 arg3 = wxString_in_helper(obj2);
38075 if (arg3 == NULL) SWIG_fail;
38076 temp3 = true;
38077 }
38078 {
38079 PyThreadState* __tstate = wxPyBeginAllowThreads();
38080 (arg1)->SetString(arg2,(wxString const &)*arg3);
38081
38082 wxPyEndAllowThreads(__tstate);
38083 if (PyErr_Occurred()) SWIG_fail;
38084 }
38085 Py_INCREF(Py_None); resultobj = Py_None;
38086 {
38087 if (temp3)
38088 delete arg3;
38089 }
38090 return resultobj;
38091 fail:
38092 {
38093 if (temp3)
38094 delete arg3;
38095 }
38096 return NULL;
38097 }
38098
38099
38100 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38101 PyObject *resultobj;
38102 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38103 wxString *arg2 = 0 ;
38104 int result;
38105 bool temp2 = false ;
38106 PyObject * obj0 = 0 ;
38107 PyObject * obj1 = 0 ;
38108 char *kwnames[] = {
38109 (char *) "self",(char *) "s", NULL
38110 };
38111
38112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38114 if (SWIG_arg_fail(1)) SWIG_fail;
38115 {
38116 arg2 = wxString_in_helper(obj1);
38117 if (arg2 == NULL) SWIG_fail;
38118 temp2 = true;
38119 }
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38123
38124 wxPyEndAllowThreads(__tstate);
38125 if (PyErr_Occurred()) SWIG_fail;
38126 }
38127 {
38128 resultobj = SWIG_From_int((int)(result));
38129 }
38130 {
38131 if (temp2)
38132 delete arg2;
38133 }
38134 return resultobj;
38135 fail:
38136 {
38137 if (temp2)
38138 delete arg2;
38139 }
38140 return NULL;
38141 }
38142
38143
38144 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38145 PyObject *resultobj;
38146 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38147 int arg2 ;
38148 PyObject * obj0 = 0 ;
38149 PyObject * obj1 = 0 ;
38150 char *kwnames[] = {
38151 (char *) "self",(char *) "n", NULL
38152 };
38153
38154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38156 if (SWIG_arg_fail(1)) SWIG_fail;
38157 {
38158 arg2 = (int)(SWIG_As_int(obj1));
38159 if (SWIG_arg_fail(2)) SWIG_fail;
38160 }
38161 {
38162 PyThreadState* __tstate = wxPyBeginAllowThreads();
38163 (arg1)->SetSelection(arg2);
38164
38165 wxPyEndAllowThreads(__tstate);
38166 if (PyErr_Occurred()) SWIG_fail;
38167 }
38168 Py_INCREF(Py_None); resultobj = Py_None;
38169 return resultobj;
38170 fail:
38171 return NULL;
38172 }
38173
38174
38175 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38176 PyObject *resultobj;
38177 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38178 int result;
38179 PyObject * obj0 = 0 ;
38180 char *kwnames[] = {
38181 (char *) "self", NULL
38182 };
38183
38184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38186 if (SWIG_arg_fail(1)) SWIG_fail;
38187 {
38188 PyThreadState* __tstate = wxPyBeginAllowThreads();
38189 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38190
38191 wxPyEndAllowThreads(__tstate);
38192 if (PyErr_Occurred()) SWIG_fail;
38193 }
38194 {
38195 resultobj = SWIG_From_int((int)(result));
38196 }
38197 return resultobj;
38198 fail:
38199 return NULL;
38200 }
38201
38202
38203 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38204 PyObject *resultobj;
38205 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38206 wxString *arg2 = 0 ;
38207 bool result;
38208 bool temp2 = false ;
38209 PyObject * obj0 = 0 ;
38210 PyObject * obj1 = 0 ;
38211 char *kwnames[] = {
38212 (char *) "self",(char *) "s", NULL
38213 };
38214
38215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38217 if (SWIG_arg_fail(1)) SWIG_fail;
38218 {
38219 arg2 = wxString_in_helper(obj1);
38220 if (arg2 == NULL) SWIG_fail;
38221 temp2 = true;
38222 }
38223 {
38224 PyThreadState* __tstate = wxPyBeginAllowThreads();
38225 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38226
38227 wxPyEndAllowThreads(__tstate);
38228 if (PyErr_Occurred()) SWIG_fail;
38229 }
38230 {
38231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38232 }
38233 {
38234 if (temp2)
38235 delete arg2;
38236 }
38237 return resultobj;
38238 fail:
38239 {
38240 if (temp2)
38241 delete arg2;
38242 }
38243 return NULL;
38244 }
38245
38246
38247 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38248 PyObject *resultobj;
38249 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38250 wxString result;
38251 PyObject * obj0 = 0 ;
38252 char *kwnames[] = {
38253 (char *) "self", NULL
38254 };
38255
38256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38258 if (SWIG_arg_fail(1)) SWIG_fail;
38259 {
38260 PyThreadState* __tstate = wxPyBeginAllowThreads();
38261 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38262
38263 wxPyEndAllowThreads(__tstate);
38264 if (PyErr_Occurred()) SWIG_fail;
38265 }
38266 {
38267 #if wxUSE_UNICODE
38268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38269 #else
38270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38271 #endif
38272 }
38273 return resultobj;
38274 fail:
38275 return NULL;
38276 }
38277
38278
38279 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38280 PyObject *resultobj;
38281 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38282 int arg2 ;
38283 PyObject * obj0 = 0 ;
38284 PyObject * obj1 = 0 ;
38285 char *kwnames[] = {
38286 (char *) "self",(char *) "n", NULL
38287 };
38288
38289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38291 if (SWIG_arg_fail(1)) SWIG_fail;
38292 {
38293 arg2 = (int)(SWIG_As_int(obj1));
38294 if (SWIG_arg_fail(2)) SWIG_fail;
38295 }
38296 {
38297 PyThreadState* __tstate = wxPyBeginAllowThreads();
38298 (arg1)->Select(arg2);
38299
38300 wxPyEndAllowThreads(__tstate);
38301 if (PyErr_Occurred()) SWIG_fail;
38302 }
38303 Py_INCREF(Py_None); resultobj = Py_None;
38304 return resultobj;
38305 fail:
38306 return NULL;
38307 }
38308
38309
38310 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38311 PyObject *obj;
38312 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38313 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38314 Py_INCREF(obj);
38315 return Py_BuildValue((char *)"");
38316 }
38317 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38318 PyObject *obj;
38319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38320 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38321 Py_INCREF(obj);
38322 return Py_BuildValue((char *)"");
38323 }
38324 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38325 PyObject *resultobj;
38326 wxSizerItem *result;
38327 char *kwnames[] = {
38328 NULL
38329 };
38330
38331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38332 {
38333 PyThreadState* __tstate = wxPyBeginAllowThreads();
38334 result = (wxSizerItem *)new wxSizerItem();
38335
38336 wxPyEndAllowThreads(__tstate);
38337 if (PyErr_Occurred()) SWIG_fail;
38338 }
38339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38340 return resultobj;
38341 fail:
38342 return NULL;
38343 }
38344
38345
38346 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38347 PyObject *resultobj;
38348 wxWindow *arg1 = (wxWindow *) 0 ;
38349 int arg2 ;
38350 int arg3 ;
38351 int arg4 ;
38352 PyObject *arg5 = (PyObject *) NULL ;
38353 wxSizerItem *result;
38354 PyObject * obj0 = 0 ;
38355 PyObject * obj1 = 0 ;
38356 PyObject * obj2 = 0 ;
38357 PyObject * obj3 = 0 ;
38358 PyObject * obj4 = 0 ;
38359 char *kwnames[] = {
38360 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38361 };
38362
38363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38365 if (SWIG_arg_fail(1)) SWIG_fail;
38366 {
38367 arg2 = (int)(SWIG_As_int(obj1));
38368 if (SWIG_arg_fail(2)) SWIG_fail;
38369 }
38370 {
38371 arg3 = (int)(SWIG_As_int(obj2));
38372 if (SWIG_arg_fail(3)) SWIG_fail;
38373 }
38374 {
38375 arg4 = (int)(SWIG_As_int(obj3));
38376 if (SWIG_arg_fail(4)) SWIG_fail;
38377 }
38378 if (obj4) {
38379 arg5 = obj4;
38380 }
38381 {
38382 PyThreadState* __tstate = wxPyBeginAllowThreads();
38383 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38384
38385 wxPyEndAllowThreads(__tstate);
38386 if (PyErr_Occurred()) SWIG_fail;
38387 }
38388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38389 return resultobj;
38390 fail:
38391 return NULL;
38392 }
38393
38394
38395 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj;
38397 int arg1 ;
38398 int arg2 ;
38399 int arg3 ;
38400 int arg4 ;
38401 int arg5 ;
38402 PyObject *arg6 = (PyObject *) NULL ;
38403 wxSizerItem *result;
38404 PyObject * obj0 = 0 ;
38405 PyObject * obj1 = 0 ;
38406 PyObject * obj2 = 0 ;
38407 PyObject * obj3 = 0 ;
38408 PyObject * obj4 = 0 ;
38409 PyObject * obj5 = 0 ;
38410 char *kwnames[] = {
38411 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38412 };
38413
38414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38415 {
38416 arg1 = (int)(SWIG_As_int(obj0));
38417 if (SWIG_arg_fail(1)) SWIG_fail;
38418 }
38419 {
38420 arg2 = (int)(SWIG_As_int(obj1));
38421 if (SWIG_arg_fail(2)) SWIG_fail;
38422 }
38423 {
38424 arg3 = (int)(SWIG_As_int(obj2));
38425 if (SWIG_arg_fail(3)) SWIG_fail;
38426 }
38427 {
38428 arg4 = (int)(SWIG_As_int(obj3));
38429 if (SWIG_arg_fail(4)) SWIG_fail;
38430 }
38431 {
38432 arg5 = (int)(SWIG_As_int(obj4));
38433 if (SWIG_arg_fail(5)) SWIG_fail;
38434 }
38435 if (obj5) {
38436 arg6 = obj5;
38437 }
38438 {
38439 PyThreadState* __tstate = wxPyBeginAllowThreads();
38440 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38441
38442 wxPyEndAllowThreads(__tstate);
38443 if (PyErr_Occurred()) SWIG_fail;
38444 }
38445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38446 return resultobj;
38447 fail:
38448 return NULL;
38449 }
38450
38451
38452 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38453 PyObject *resultobj;
38454 wxSizer *arg1 = (wxSizer *) 0 ;
38455 int arg2 ;
38456 int arg3 ;
38457 int arg4 ;
38458 PyObject *arg5 = (PyObject *) NULL ;
38459 wxSizerItem *result;
38460 PyObject * obj0 = 0 ;
38461 PyObject * obj1 = 0 ;
38462 PyObject * obj2 = 0 ;
38463 PyObject * obj3 = 0 ;
38464 PyObject * obj4 = 0 ;
38465 char *kwnames[] = {
38466 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38467 };
38468
38469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38471 if (SWIG_arg_fail(1)) SWIG_fail;
38472 {
38473 arg2 = (int)(SWIG_As_int(obj1));
38474 if (SWIG_arg_fail(2)) SWIG_fail;
38475 }
38476 {
38477 arg3 = (int)(SWIG_As_int(obj2));
38478 if (SWIG_arg_fail(3)) SWIG_fail;
38479 }
38480 {
38481 arg4 = (int)(SWIG_As_int(obj3));
38482 if (SWIG_arg_fail(4)) SWIG_fail;
38483 }
38484 if (obj4) {
38485 arg5 = obj4;
38486 }
38487 {
38488 PyThreadState* __tstate = wxPyBeginAllowThreads();
38489 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38490
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38495 return resultobj;
38496 fail:
38497 return NULL;
38498 }
38499
38500
38501 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38502 PyObject *resultobj;
38503 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38504 PyObject * obj0 = 0 ;
38505 char *kwnames[] = {
38506 (char *) "self", NULL
38507 };
38508
38509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38511 if (SWIG_arg_fail(1)) SWIG_fail;
38512 {
38513 PyThreadState* __tstate = wxPyBeginAllowThreads();
38514 (arg1)->DeleteWindows();
38515
38516 wxPyEndAllowThreads(__tstate);
38517 if (PyErr_Occurred()) SWIG_fail;
38518 }
38519 Py_INCREF(Py_None); resultobj = Py_None;
38520 return resultobj;
38521 fail:
38522 return NULL;
38523 }
38524
38525
38526 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38527 PyObject *resultobj;
38528 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38529 PyObject * obj0 = 0 ;
38530 char *kwnames[] = {
38531 (char *) "self", NULL
38532 };
38533
38534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",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 (arg1)->DetachSizer();
38540
38541 wxPyEndAllowThreads(__tstate);
38542 if (PyErr_Occurred()) SWIG_fail;
38543 }
38544 Py_INCREF(Py_None); resultobj = Py_None;
38545 return resultobj;
38546 fail:
38547 return NULL;
38548 }
38549
38550
38551 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38552 PyObject *resultobj;
38553 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38554 wxSize result;
38555 PyObject * obj0 = 0 ;
38556 char *kwnames[] = {
38557 (char *) "self", NULL
38558 };
38559
38560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38562 if (SWIG_arg_fail(1)) SWIG_fail;
38563 {
38564 PyThreadState* __tstate = wxPyBeginAllowThreads();
38565 result = (arg1)->GetSize();
38566
38567 wxPyEndAllowThreads(__tstate);
38568 if (PyErr_Occurred()) SWIG_fail;
38569 }
38570 {
38571 wxSize * resultptr;
38572 resultptr = new wxSize((wxSize &)(result));
38573 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38574 }
38575 return resultobj;
38576 fail:
38577 return NULL;
38578 }
38579
38580
38581 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38582 PyObject *resultobj;
38583 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38584 wxSize result;
38585 PyObject * obj0 = 0 ;
38586 char *kwnames[] = {
38587 (char *) "self", NULL
38588 };
38589
38590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38592 if (SWIG_arg_fail(1)) SWIG_fail;
38593 {
38594 PyThreadState* __tstate = wxPyBeginAllowThreads();
38595 result = (arg1)->CalcMin();
38596
38597 wxPyEndAllowThreads(__tstate);
38598 if (PyErr_Occurred()) SWIG_fail;
38599 }
38600 {
38601 wxSize * resultptr;
38602 resultptr = new wxSize((wxSize &)(result));
38603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38604 }
38605 return resultobj;
38606 fail:
38607 return NULL;
38608 }
38609
38610
38611 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38612 PyObject *resultobj;
38613 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38614 wxPoint arg2 ;
38615 wxSize arg3 ;
38616 PyObject * obj0 = 0 ;
38617 PyObject * obj1 = 0 ;
38618 PyObject * obj2 = 0 ;
38619 char *kwnames[] = {
38620 (char *) "self",(char *) "pos",(char *) "size", NULL
38621 };
38622
38623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38625 if (SWIG_arg_fail(1)) SWIG_fail;
38626 {
38627 wxPoint * argp;
38628 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38629 if (SWIG_arg_fail(2)) SWIG_fail;
38630 if (argp == NULL) {
38631 SWIG_null_ref("wxPoint");
38632 }
38633 if (SWIG_arg_fail(2)) SWIG_fail;
38634 arg2 = *argp;
38635 }
38636 {
38637 wxSize * argp;
38638 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38639 if (SWIG_arg_fail(3)) SWIG_fail;
38640 if (argp == NULL) {
38641 SWIG_null_ref("wxSize");
38642 }
38643 if (SWIG_arg_fail(3)) SWIG_fail;
38644 arg3 = *argp;
38645 }
38646 {
38647 PyThreadState* __tstate = wxPyBeginAllowThreads();
38648 (arg1)->SetDimension(arg2,arg3);
38649
38650 wxPyEndAllowThreads(__tstate);
38651 if (PyErr_Occurred()) SWIG_fail;
38652 }
38653 Py_INCREF(Py_None); resultobj = Py_None;
38654 return resultobj;
38655 fail:
38656 return NULL;
38657 }
38658
38659
38660 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38661 PyObject *resultobj;
38662 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38663 wxSize result;
38664 PyObject * obj0 = 0 ;
38665 char *kwnames[] = {
38666 (char *) "self", NULL
38667 };
38668
38669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38671 if (SWIG_arg_fail(1)) SWIG_fail;
38672 {
38673 PyThreadState* __tstate = wxPyBeginAllowThreads();
38674 result = (arg1)->GetMinSize();
38675
38676 wxPyEndAllowThreads(__tstate);
38677 if (PyErr_Occurred()) SWIG_fail;
38678 }
38679 {
38680 wxSize * resultptr;
38681 resultptr = new wxSize((wxSize &)(result));
38682 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38683 }
38684 return resultobj;
38685 fail:
38686 return NULL;
38687 }
38688
38689
38690 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38691 PyObject *resultobj;
38692 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38693 wxSize result;
38694 PyObject * obj0 = 0 ;
38695 char *kwnames[] = {
38696 (char *) "self", NULL
38697 };
38698
38699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38701 if (SWIG_arg_fail(1)) SWIG_fail;
38702 {
38703 PyThreadState* __tstate = wxPyBeginAllowThreads();
38704 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38705
38706 wxPyEndAllowThreads(__tstate);
38707 if (PyErr_Occurred()) SWIG_fail;
38708 }
38709 {
38710 wxSize * resultptr;
38711 resultptr = new wxSize((wxSize &)(result));
38712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38713 }
38714 return resultobj;
38715 fail:
38716 return NULL;
38717 }
38718
38719
38720 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38721 PyObject *resultobj;
38722 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38723 int arg2 ;
38724 int arg3 ;
38725 PyObject * obj0 = 0 ;
38726 PyObject * obj1 = 0 ;
38727 PyObject * obj2 = 0 ;
38728 char *kwnames[] = {
38729 (char *) "self",(char *) "x",(char *) "y", NULL
38730 };
38731
38732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38734 if (SWIG_arg_fail(1)) SWIG_fail;
38735 {
38736 arg2 = (int)(SWIG_As_int(obj1));
38737 if (SWIG_arg_fail(2)) SWIG_fail;
38738 }
38739 {
38740 arg3 = (int)(SWIG_As_int(obj2));
38741 if (SWIG_arg_fail(3)) SWIG_fail;
38742 }
38743 {
38744 PyThreadState* __tstate = wxPyBeginAllowThreads();
38745 (arg1)->SetInitSize(arg2,arg3);
38746
38747 wxPyEndAllowThreads(__tstate);
38748 if (PyErr_Occurred()) SWIG_fail;
38749 }
38750 Py_INCREF(Py_None); resultobj = Py_None;
38751 return resultobj;
38752 fail:
38753 return NULL;
38754 }
38755
38756
38757 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38758 PyObject *resultobj;
38759 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38760 int arg2 ;
38761 int arg3 ;
38762 PyObject * obj0 = 0 ;
38763 PyObject * obj1 = 0 ;
38764 PyObject * obj2 = 0 ;
38765 char *kwnames[] = {
38766 (char *) "self",(char *) "width",(char *) "height", NULL
38767 };
38768
38769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38771 if (SWIG_arg_fail(1)) SWIG_fail;
38772 {
38773 arg2 = (int)(SWIG_As_int(obj1));
38774 if (SWIG_arg_fail(2)) SWIG_fail;
38775 }
38776 {
38777 arg3 = (int)(SWIG_As_int(obj2));
38778 if (SWIG_arg_fail(3)) SWIG_fail;
38779 }
38780 {
38781 PyThreadState* __tstate = wxPyBeginAllowThreads();
38782 (arg1)->SetRatio(arg2,arg3);
38783
38784 wxPyEndAllowThreads(__tstate);
38785 if (PyErr_Occurred()) SWIG_fail;
38786 }
38787 Py_INCREF(Py_None); resultobj = Py_None;
38788 return resultobj;
38789 fail:
38790 return NULL;
38791 }
38792
38793
38794 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38795 PyObject *resultobj;
38796 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38797 wxSize *arg2 = 0 ;
38798 wxSize temp2 ;
38799 PyObject * obj0 = 0 ;
38800 PyObject * obj1 = 0 ;
38801 char *kwnames[] = {
38802 (char *) "self",(char *) "size", NULL
38803 };
38804
38805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38807 if (SWIG_arg_fail(1)) SWIG_fail;
38808 {
38809 arg2 = &temp2;
38810 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38811 }
38812 {
38813 PyThreadState* __tstate = wxPyBeginAllowThreads();
38814 (arg1)->SetRatio((wxSize const &)*arg2);
38815
38816 wxPyEndAllowThreads(__tstate);
38817 if (PyErr_Occurred()) SWIG_fail;
38818 }
38819 Py_INCREF(Py_None); resultobj = Py_None;
38820 return resultobj;
38821 fail:
38822 return NULL;
38823 }
38824
38825
38826 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38827 PyObject *resultobj;
38828 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38829 float arg2 ;
38830 PyObject * obj0 = 0 ;
38831 PyObject * obj1 = 0 ;
38832 char *kwnames[] = {
38833 (char *) "self",(char *) "ratio", NULL
38834 };
38835
38836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38838 if (SWIG_arg_fail(1)) SWIG_fail;
38839 {
38840 arg2 = (float)(SWIG_As_float(obj1));
38841 if (SWIG_arg_fail(2)) SWIG_fail;
38842 }
38843 {
38844 PyThreadState* __tstate = wxPyBeginAllowThreads();
38845 (arg1)->SetRatio(arg2);
38846
38847 wxPyEndAllowThreads(__tstate);
38848 if (PyErr_Occurred()) SWIG_fail;
38849 }
38850 Py_INCREF(Py_None); resultobj = Py_None;
38851 return resultobj;
38852 fail:
38853 return NULL;
38854 }
38855
38856
38857 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38858 PyObject *resultobj;
38859 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38860 float result;
38861 PyObject * obj0 = 0 ;
38862 char *kwnames[] = {
38863 (char *) "self", NULL
38864 };
38865
38866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38868 if (SWIG_arg_fail(1)) SWIG_fail;
38869 {
38870 PyThreadState* __tstate = wxPyBeginAllowThreads();
38871 result = (float)(arg1)->GetRatio();
38872
38873 wxPyEndAllowThreads(__tstate);
38874 if (PyErr_Occurred()) SWIG_fail;
38875 }
38876 {
38877 resultobj = SWIG_From_float((float)(result));
38878 }
38879 return resultobj;
38880 fail:
38881 return NULL;
38882 }
38883
38884
38885 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38886 PyObject *resultobj;
38887 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38888 wxRect result;
38889 PyObject * obj0 = 0 ;
38890 char *kwnames[] = {
38891 (char *) "self", NULL
38892 };
38893
38894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38896 if (SWIG_arg_fail(1)) SWIG_fail;
38897 {
38898 PyThreadState* __tstate = wxPyBeginAllowThreads();
38899 result = (arg1)->GetRect();
38900
38901 wxPyEndAllowThreads(__tstate);
38902 if (PyErr_Occurred()) SWIG_fail;
38903 }
38904 {
38905 wxRect * resultptr;
38906 resultptr = new wxRect((wxRect &)(result));
38907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38908 }
38909 return resultobj;
38910 fail:
38911 return NULL;
38912 }
38913
38914
38915 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38916 PyObject *resultobj;
38917 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38918 bool result;
38919 PyObject * obj0 = 0 ;
38920 char *kwnames[] = {
38921 (char *) "self", NULL
38922 };
38923
38924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38926 if (SWIG_arg_fail(1)) SWIG_fail;
38927 {
38928 PyThreadState* __tstate = wxPyBeginAllowThreads();
38929 result = (bool)(arg1)->IsWindow();
38930
38931 wxPyEndAllowThreads(__tstate);
38932 if (PyErr_Occurred()) SWIG_fail;
38933 }
38934 {
38935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38936 }
38937 return resultobj;
38938 fail:
38939 return NULL;
38940 }
38941
38942
38943 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38944 PyObject *resultobj;
38945 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38946 bool result;
38947 PyObject * obj0 = 0 ;
38948 char *kwnames[] = {
38949 (char *) "self", NULL
38950 };
38951
38952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38954 if (SWIG_arg_fail(1)) SWIG_fail;
38955 {
38956 PyThreadState* __tstate = wxPyBeginAllowThreads();
38957 result = (bool)(arg1)->IsSizer();
38958
38959 wxPyEndAllowThreads(__tstate);
38960 if (PyErr_Occurred()) SWIG_fail;
38961 }
38962 {
38963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38964 }
38965 return resultobj;
38966 fail:
38967 return NULL;
38968 }
38969
38970
38971 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38972 PyObject *resultobj;
38973 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38974 bool result;
38975 PyObject * obj0 = 0 ;
38976 char *kwnames[] = {
38977 (char *) "self", NULL
38978 };
38979
38980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38982 if (SWIG_arg_fail(1)) SWIG_fail;
38983 {
38984 PyThreadState* __tstate = wxPyBeginAllowThreads();
38985 result = (bool)(arg1)->IsSpacer();
38986
38987 wxPyEndAllowThreads(__tstate);
38988 if (PyErr_Occurred()) SWIG_fail;
38989 }
38990 {
38991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38992 }
38993 return resultobj;
38994 fail:
38995 return NULL;
38996 }
38997
38998
38999 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39000 PyObject *resultobj;
39001 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39002 int arg2 ;
39003 PyObject * obj0 = 0 ;
39004 PyObject * obj1 = 0 ;
39005 char *kwnames[] = {
39006 (char *) "self",(char *) "proportion", NULL
39007 };
39008
39009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39011 if (SWIG_arg_fail(1)) SWIG_fail;
39012 {
39013 arg2 = (int)(SWIG_As_int(obj1));
39014 if (SWIG_arg_fail(2)) SWIG_fail;
39015 }
39016 {
39017 PyThreadState* __tstate = wxPyBeginAllowThreads();
39018 (arg1)->SetProportion(arg2);
39019
39020 wxPyEndAllowThreads(__tstate);
39021 if (PyErr_Occurred()) SWIG_fail;
39022 }
39023 Py_INCREF(Py_None); resultobj = Py_None;
39024 return resultobj;
39025 fail:
39026 return NULL;
39027 }
39028
39029
39030 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39031 PyObject *resultobj;
39032 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39033 int result;
39034 PyObject * obj0 = 0 ;
39035 char *kwnames[] = {
39036 (char *) "self", NULL
39037 };
39038
39039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39041 if (SWIG_arg_fail(1)) SWIG_fail;
39042 {
39043 PyThreadState* __tstate = wxPyBeginAllowThreads();
39044 result = (int)(arg1)->GetProportion();
39045
39046 wxPyEndAllowThreads(__tstate);
39047 if (PyErr_Occurred()) SWIG_fail;
39048 }
39049 {
39050 resultobj = SWIG_From_int((int)(result));
39051 }
39052 return resultobj;
39053 fail:
39054 return NULL;
39055 }
39056
39057
39058 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39059 PyObject *resultobj;
39060 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39061 int arg2 ;
39062 PyObject * obj0 = 0 ;
39063 PyObject * obj1 = 0 ;
39064 char *kwnames[] = {
39065 (char *) "self",(char *) "flag", NULL
39066 };
39067
39068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39070 if (SWIG_arg_fail(1)) SWIG_fail;
39071 {
39072 arg2 = (int)(SWIG_As_int(obj1));
39073 if (SWIG_arg_fail(2)) SWIG_fail;
39074 }
39075 {
39076 PyThreadState* __tstate = wxPyBeginAllowThreads();
39077 (arg1)->SetFlag(arg2);
39078
39079 wxPyEndAllowThreads(__tstate);
39080 if (PyErr_Occurred()) SWIG_fail;
39081 }
39082 Py_INCREF(Py_None); resultobj = Py_None;
39083 return resultobj;
39084 fail:
39085 return NULL;
39086 }
39087
39088
39089 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39090 PyObject *resultobj;
39091 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39092 int result;
39093 PyObject * obj0 = 0 ;
39094 char *kwnames[] = {
39095 (char *) "self", NULL
39096 };
39097
39098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39100 if (SWIG_arg_fail(1)) SWIG_fail;
39101 {
39102 PyThreadState* __tstate = wxPyBeginAllowThreads();
39103 result = (int)(arg1)->GetFlag();
39104
39105 wxPyEndAllowThreads(__tstate);
39106 if (PyErr_Occurred()) SWIG_fail;
39107 }
39108 {
39109 resultobj = SWIG_From_int((int)(result));
39110 }
39111 return resultobj;
39112 fail:
39113 return NULL;
39114 }
39115
39116
39117 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39118 PyObject *resultobj;
39119 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39120 int arg2 ;
39121 PyObject * obj0 = 0 ;
39122 PyObject * obj1 = 0 ;
39123 char *kwnames[] = {
39124 (char *) "self",(char *) "border", NULL
39125 };
39126
39127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39129 if (SWIG_arg_fail(1)) SWIG_fail;
39130 {
39131 arg2 = (int)(SWIG_As_int(obj1));
39132 if (SWIG_arg_fail(2)) SWIG_fail;
39133 }
39134 {
39135 PyThreadState* __tstate = wxPyBeginAllowThreads();
39136 (arg1)->SetBorder(arg2);
39137
39138 wxPyEndAllowThreads(__tstate);
39139 if (PyErr_Occurred()) SWIG_fail;
39140 }
39141 Py_INCREF(Py_None); resultobj = Py_None;
39142 return resultobj;
39143 fail:
39144 return NULL;
39145 }
39146
39147
39148 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39149 PyObject *resultobj;
39150 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39151 int result;
39152 PyObject * obj0 = 0 ;
39153 char *kwnames[] = {
39154 (char *) "self", NULL
39155 };
39156
39157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39159 if (SWIG_arg_fail(1)) SWIG_fail;
39160 {
39161 PyThreadState* __tstate = wxPyBeginAllowThreads();
39162 result = (int)(arg1)->GetBorder();
39163
39164 wxPyEndAllowThreads(__tstate);
39165 if (PyErr_Occurred()) SWIG_fail;
39166 }
39167 {
39168 resultobj = SWIG_From_int((int)(result));
39169 }
39170 return resultobj;
39171 fail:
39172 return NULL;
39173 }
39174
39175
39176 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39177 PyObject *resultobj;
39178 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39179 wxWindow *result;
39180 PyObject * obj0 = 0 ;
39181 char *kwnames[] = {
39182 (char *) "self", NULL
39183 };
39184
39185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39187 if (SWIG_arg_fail(1)) SWIG_fail;
39188 {
39189 PyThreadState* __tstate = wxPyBeginAllowThreads();
39190 result = (wxWindow *)(arg1)->GetWindow();
39191
39192 wxPyEndAllowThreads(__tstate);
39193 if (PyErr_Occurred()) SWIG_fail;
39194 }
39195 {
39196 resultobj = wxPyMake_wxObject(result, 0);
39197 }
39198 return resultobj;
39199 fail:
39200 return NULL;
39201 }
39202
39203
39204 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39205 PyObject *resultobj;
39206 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39207 wxWindow *arg2 = (wxWindow *) 0 ;
39208 PyObject * obj0 = 0 ;
39209 PyObject * obj1 = 0 ;
39210 char *kwnames[] = {
39211 (char *) "self",(char *) "window", NULL
39212 };
39213
39214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39216 if (SWIG_arg_fail(1)) SWIG_fail;
39217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39218 if (SWIG_arg_fail(2)) SWIG_fail;
39219 {
39220 PyThreadState* __tstate = wxPyBeginAllowThreads();
39221 (arg1)->SetWindow(arg2);
39222
39223 wxPyEndAllowThreads(__tstate);
39224 if (PyErr_Occurred()) SWIG_fail;
39225 }
39226 Py_INCREF(Py_None); resultobj = Py_None;
39227 return resultobj;
39228 fail:
39229 return NULL;
39230 }
39231
39232
39233 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39234 PyObject *resultobj;
39235 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39236 wxSizer *result;
39237 PyObject * obj0 = 0 ;
39238 char *kwnames[] = {
39239 (char *) "self", NULL
39240 };
39241
39242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39244 if (SWIG_arg_fail(1)) SWIG_fail;
39245 {
39246 PyThreadState* __tstate = wxPyBeginAllowThreads();
39247 result = (wxSizer *)(arg1)->GetSizer();
39248
39249 wxPyEndAllowThreads(__tstate);
39250 if (PyErr_Occurred()) SWIG_fail;
39251 }
39252 {
39253 resultobj = wxPyMake_wxSizer(result, 0);
39254 }
39255 return resultobj;
39256 fail:
39257 return NULL;
39258 }
39259
39260
39261 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39262 PyObject *resultobj;
39263 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39264 wxSizer *arg2 = (wxSizer *) 0 ;
39265 PyObject * obj0 = 0 ;
39266 PyObject * obj1 = 0 ;
39267 char *kwnames[] = {
39268 (char *) "self",(char *) "sizer", NULL
39269 };
39270
39271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39273 if (SWIG_arg_fail(1)) SWIG_fail;
39274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39275 if (SWIG_arg_fail(2)) SWIG_fail;
39276 {
39277 PyThreadState* __tstate = wxPyBeginAllowThreads();
39278 (arg1)->SetSizer(arg2);
39279
39280 wxPyEndAllowThreads(__tstate);
39281 if (PyErr_Occurred()) SWIG_fail;
39282 }
39283 Py_INCREF(Py_None); resultobj = Py_None;
39284 return resultobj;
39285 fail:
39286 return NULL;
39287 }
39288
39289
39290 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39291 PyObject *resultobj;
39292 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39293 wxSize *result;
39294 PyObject * obj0 = 0 ;
39295 char *kwnames[] = {
39296 (char *) "self", NULL
39297 };
39298
39299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39301 if (SWIG_arg_fail(1)) SWIG_fail;
39302 {
39303 PyThreadState* __tstate = wxPyBeginAllowThreads();
39304 {
39305 wxSize const &_result_ref = (arg1)->GetSpacer();
39306 result = (wxSize *) &_result_ref;
39307 }
39308
39309 wxPyEndAllowThreads(__tstate);
39310 if (PyErr_Occurred()) SWIG_fail;
39311 }
39312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39313 return resultobj;
39314 fail:
39315 return NULL;
39316 }
39317
39318
39319 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39320 PyObject *resultobj;
39321 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39322 wxSize *arg2 = 0 ;
39323 wxSize temp2 ;
39324 PyObject * obj0 = 0 ;
39325 PyObject * obj1 = 0 ;
39326 char *kwnames[] = {
39327 (char *) "self",(char *) "size", NULL
39328 };
39329
39330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39332 if (SWIG_arg_fail(1)) SWIG_fail;
39333 {
39334 arg2 = &temp2;
39335 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39336 }
39337 {
39338 PyThreadState* __tstate = wxPyBeginAllowThreads();
39339 (arg1)->SetSpacer((wxSize const &)*arg2);
39340
39341 wxPyEndAllowThreads(__tstate);
39342 if (PyErr_Occurred()) SWIG_fail;
39343 }
39344 Py_INCREF(Py_None); resultobj = Py_None;
39345 return resultobj;
39346 fail:
39347 return NULL;
39348 }
39349
39350
39351 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39352 PyObject *resultobj;
39353 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39354 bool arg2 ;
39355 PyObject * obj0 = 0 ;
39356 PyObject * obj1 = 0 ;
39357 char *kwnames[] = {
39358 (char *) "self",(char *) "show", NULL
39359 };
39360
39361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39363 if (SWIG_arg_fail(1)) SWIG_fail;
39364 {
39365 arg2 = (bool)(SWIG_As_bool(obj1));
39366 if (SWIG_arg_fail(2)) SWIG_fail;
39367 }
39368 {
39369 PyThreadState* __tstate = wxPyBeginAllowThreads();
39370 (arg1)->Show(arg2);
39371
39372 wxPyEndAllowThreads(__tstate);
39373 if (PyErr_Occurred()) SWIG_fail;
39374 }
39375 Py_INCREF(Py_None); resultobj = Py_None;
39376 return resultobj;
39377 fail:
39378 return NULL;
39379 }
39380
39381
39382 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39383 PyObject *resultobj;
39384 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39385 bool result;
39386 PyObject * obj0 = 0 ;
39387 char *kwnames[] = {
39388 (char *) "self", NULL
39389 };
39390
39391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39393 if (SWIG_arg_fail(1)) SWIG_fail;
39394 {
39395 PyThreadState* __tstate = wxPyBeginAllowThreads();
39396 result = (bool)(arg1)->IsShown();
39397
39398 wxPyEndAllowThreads(__tstate);
39399 if (PyErr_Occurred()) SWIG_fail;
39400 }
39401 {
39402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39403 }
39404 return resultobj;
39405 fail:
39406 return NULL;
39407 }
39408
39409
39410 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39411 PyObject *resultobj;
39412 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39413 wxPoint result;
39414 PyObject * obj0 = 0 ;
39415 char *kwnames[] = {
39416 (char *) "self", NULL
39417 };
39418
39419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39421 if (SWIG_arg_fail(1)) SWIG_fail;
39422 {
39423 PyThreadState* __tstate = wxPyBeginAllowThreads();
39424 result = (arg1)->GetPosition();
39425
39426 wxPyEndAllowThreads(__tstate);
39427 if (PyErr_Occurred()) SWIG_fail;
39428 }
39429 {
39430 wxPoint * resultptr;
39431 resultptr = new wxPoint((wxPoint &)(result));
39432 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39433 }
39434 return resultobj;
39435 fail:
39436 return NULL;
39437 }
39438
39439
39440 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39441 PyObject *resultobj;
39442 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39443 PyObject *result;
39444 PyObject * obj0 = 0 ;
39445 char *kwnames[] = {
39446 (char *) "self", NULL
39447 };
39448
39449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39451 if (SWIG_arg_fail(1)) SWIG_fail;
39452 {
39453 PyThreadState* __tstate = wxPyBeginAllowThreads();
39454 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39455
39456 wxPyEndAllowThreads(__tstate);
39457 if (PyErr_Occurred()) SWIG_fail;
39458 }
39459 resultobj = result;
39460 return resultobj;
39461 fail:
39462 return NULL;
39463 }
39464
39465
39466 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39467 PyObject *obj;
39468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39469 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39470 Py_INCREF(obj);
39471 return Py_BuildValue((char *)"");
39472 }
39473 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39474 PyObject *resultobj;
39475 wxSizer *arg1 = (wxSizer *) 0 ;
39476 PyObject *arg2 = (PyObject *) 0 ;
39477 PyObject * obj0 = 0 ;
39478 PyObject * obj1 = 0 ;
39479 char *kwnames[] = {
39480 (char *) "self",(char *) "_self", NULL
39481 };
39482
39483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39485 if (SWIG_arg_fail(1)) SWIG_fail;
39486 arg2 = obj1;
39487 {
39488 PyThreadState* __tstate = wxPyBeginAllowThreads();
39489 wxSizer__setOORInfo(arg1,arg2);
39490
39491 wxPyEndAllowThreads(__tstate);
39492 if (PyErr_Occurred()) SWIG_fail;
39493 }
39494 Py_INCREF(Py_None); resultobj = Py_None;
39495 return resultobj;
39496 fail:
39497 return NULL;
39498 }
39499
39500
39501 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39502 PyObject *resultobj;
39503 wxSizer *arg1 = (wxSizer *) 0 ;
39504 PyObject *arg2 = (PyObject *) 0 ;
39505 int arg3 = (int) 0 ;
39506 int arg4 = (int) 0 ;
39507 int arg5 = (int) 0 ;
39508 PyObject *arg6 = (PyObject *) NULL ;
39509 wxSizerItem *result;
39510 PyObject * obj0 = 0 ;
39511 PyObject * obj1 = 0 ;
39512 PyObject * obj2 = 0 ;
39513 PyObject * obj3 = 0 ;
39514 PyObject * obj4 = 0 ;
39515 PyObject * obj5 = 0 ;
39516 char *kwnames[] = {
39517 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39518 };
39519
39520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39522 if (SWIG_arg_fail(1)) SWIG_fail;
39523 arg2 = obj1;
39524 if (obj2) {
39525 {
39526 arg3 = (int)(SWIG_As_int(obj2));
39527 if (SWIG_arg_fail(3)) SWIG_fail;
39528 }
39529 }
39530 if (obj3) {
39531 {
39532 arg4 = (int)(SWIG_As_int(obj3));
39533 if (SWIG_arg_fail(4)) SWIG_fail;
39534 }
39535 }
39536 if (obj4) {
39537 {
39538 arg5 = (int)(SWIG_As_int(obj4));
39539 if (SWIG_arg_fail(5)) SWIG_fail;
39540 }
39541 }
39542 if (obj5) {
39543 arg6 = obj5;
39544 }
39545 {
39546 PyThreadState* __tstate = wxPyBeginAllowThreads();
39547 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39548
39549 wxPyEndAllowThreads(__tstate);
39550 if (PyErr_Occurred()) SWIG_fail;
39551 }
39552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39553 return resultobj;
39554 fail:
39555 return NULL;
39556 }
39557
39558
39559 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39560 PyObject *resultobj;
39561 wxSizer *arg1 = (wxSizer *) 0 ;
39562 int arg2 ;
39563 PyObject *arg3 = (PyObject *) 0 ;
39564 int arg4 = (int) 0 ;
39565 int arg5 = (int) 0 ;
39566 int arg6 = (int) 0 ;
39567 PyObject *arg7 = (PyObject *) NULL ;
39568 wxSizerItem *result;
39569 PyObject * obj0 = 0 ;
39570 PyObject * obj1 = 0 ;
39571 PyObject * obj2 = 0 ;
39572 PyObject * obj3 = 0 ;
39573 PyObject * obj4 = 0 ;
39574 PyObject * obj5 = 0 ;
39575 PyObject * obj6 = 0 ;
39576 char *kwnames[] = {
39577 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39578 };
39579
39580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39582 if (SWIG_arg_fail(1)) SWIG_fail;
39583 {
39584 arg2 = (int)(SWIG_As_int(obj1));
39585 if (SWIG_arg_fail(2)) SWIG_fail;
39586 }
39587 arg3 = obj2;
39588 if (obj3) {
39589 {
39590 arg4 = (int)(SWIG_As_int(obj3));
39591 if (SWIG_arg_fail(4)) SWIG_fail;
39592 }
39593 }
39594 if (obj4) {
39595 {
39596 arg5 = (int)(SWIG_As_int(obj4));
39597 if (SWIG_arg_fail(5)) SWIG_fail;
39598 }
39599 }
39600 if (obj5) {
39601 {
39602 arg6 = (int)(SWIG_As_int(obj5));
39603 if (SWIG_arg_fail(6)) SWIG_fail;
39604 }
39605 }
39606 if (obj6) {
39607 arg7 = obj6;
39608 }
39609 {
39610 PyThreadState* __tstate = wxPyBeginAllowThreads();
39611 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39612
39613 wxPyEndAllowThreads(__tstate);
39614 if (PyErr_Occurred()) SWIG_fail;
39615 }
39616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39617 return resultobj;
39618 fail:
39619 return NULL;
39620 }
39621
39622
39623 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39624 PyObject *resultobj;
39625 wxSizer *arg1 = (wxSizer *) 0 ;
39626 PyObject *arg2 = (PyObject *) 0 ;
39627 int arg3 = (int) 0 ;
39628 int arg4 = (int) 0 ;
39629 int arg5 = (int) 0 ;
39630 PyObject *arg6 = (PyObject *) NULL ;
39631 wxSizerItem *result;
39632 PyObject * obj0 = 0 ;
39633 PyObject * obj1 = 0 ;
39634 PyObject * obj2 = 0 ;
39635 PyObject * obj3 = 0 ;
39636 PyObject * obj4 = 0 ;
39637 PyObject * obj5 = 0 ;
39638 char *kwnames[] = {
39639 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39640 };
39641
39642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39644 if (SWIG_arg_fail(1)) SWIG_fail;
39645 arg2 = obj1;
39646 if (obj2) {
39647 {
39648 arg3 = (int)(SWIG_As_int(obj2));
39649 if (SWIG_arg_fail(3)) SWIG_fail;
39650 }
39651 }
39652 if (obj3) {
39653 {
39654 arg4 = (int)(SWIG_As_int(obj3));
39655 if (SWIG_arg_fail(4)) SWIG_fail;
39656 }
39657 }
39658 if (obj4) {
39659 {
39660 arg5 = (int)(SWIG_As_int(obj4));
39661 if (SWIG_arg_fail(5)) SWIG_fail;
39662 }
39663 }
39664 if (obj5) {
39665 arg6 = obj5;
39666 }
39667 {
39668 PyThreadState* __tstate = wxPyBeginAllowThreads();
39669 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39670
39671 wxPyEndAllowThreads(__tstate);
39672 if (PyErr_Occurred()) SWIG_fail;
39673 }
39674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39675 return resultobj;
39676 fail:
39677 return NULL;
39678 }
39679
39680
39681 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39682 PyObject *resultobj;
39683 wxSizer *arg1 = (wxSizer *) 0 ;
39684 PyObject *arg2 = (PyObject *) 0 ;
39685 bool result;
39686 PyObject * obj0 = 0 ;
39687 PyObject * obj1 = 0 ;
39688 char *kwnames[] = {
39689 (char *) "self",(char *) "item", NULL
39690 };
39691
39692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39694 if (SWIG_arg_fail(1)) SWIG_fail;
39695 arg2 = obj1;
39696 {
39697 PyThreadState* __tstate = wxPyBeginAllowThreads();
39698 result = (bool)wxSizer_Remove(arg1,arg2);
39699
39700 wxPyEndAllowThreads(__tstate);
39701 if (PyErr_Occurred()) SWIG_fail;
39702 }
39703 {
39704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39705 }
39706 return resultobj;
39707 fail:
39708 return NULL;
39709 }
39710
39711
39712 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39713 PyObject *resultobj;
39714 wxSizer *arg1 = (wxSizer *) 0 ;
39715 PyObject *arg2 = (PyObject *) 0 ;
39716 bool result;
39717 PyObject * obj0 = 0 ;
39718 PyObject * obj1 = 0 ;
39719 char *kwnames[] = {
39720 (char *) "self",(char *) "item", NULL
39721 };
39722
39723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39725 if (SWIG_arg_fail(1)) SWIG_fail;
39726 arg2 = obj1;
39727 {
39728 PyThreadState* __tstate = wxPyBeginAllowThreads();
39729 result = (bool)wxSizer_Detach(arg1,arg2);
39730
39731 wxPyEndAllowThreads(__tstate);
39732 if (PyErr_Occurred()) SWIG_fail;
39733 }
39734 {
39735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39736 }
39737 return resultobj;
39738 fail:
39739 return NULL;
39740 }
39741
39742
39743 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39744 PyObject *resultobj;
39745 wxSizer *arg1 = (wxSizer *) 0 ;
39746 PyObject *arg2 = (PyObject *) 0 ;
39747 wxSizerItem *result;
39748 PyObject * obj0 = 0 ;
39749 PyObject * obj1 = 0 ;
39750 char *kwnames[] = {
39751 (char *) "self",(char *) "item", NULL
39752 };
39753
39754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39756 if (SWIG_arg_fail(1)) SWIG_fail;
39757 arg2 = obj1;
39758 {
39759 PyThreadState* __tstate = wxPyBeginAllowThreads();
39760 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39761
39762 wxPyEndAllowThreads(__tstate);
39763 if (PyErr_Occurred()) SWIG_fail;
39764 }
39765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39766 return resultobj;
39767 fail:
39768 return NULL;
39769 }
39770
39771
39772 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39773 PyObject *resultobj;
39774 wxSizer *arg1 = (wxSizer *) 0 ;
39775 PyObject *arg2 = (PyObject *) 0 ;
39776 wxSize *arg3 = 0 ;
39777 wxSize temp3 ;
39778 PyObject * obj0 = 0 ;
39779 PyObject * obj1 = 0 ;
39780 PyObject * obj2 = 0 ;
39781 char *kwnames[] = {
39782 (char *) "self",(char *) "item",(char *) "size", NULL
39783 };
39784
39785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39787 if (SWIG_arg_fail(1)) SWIG_fail;
39788 arg2 = obj1;
39789 {
39790 arg3 = &temp3;
39791 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39792 }
39793 {
39794 PyThreadState* __tstate = wxPyBeginAllowThreads();
39795 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39796
39797 wxPyEndAllowThreads(__tstate);
39798 if (PyErr_Occurred()) SWIG_fail;
39799 }
39800 Py_INCREF(Py_None); resultobj = Py_None;
39801 return resultobj;
39802 fail:
39803 return NULL;
39804 }
39805
39806
39807 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39808 PyObject *resultobj;
39809 wxSizer *arg1 = (wxSizer *) 0 ;
39810 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39811 wxSizerItem *result;
39812 PyObject * obj0 = 0 ;
39813 PyObject * obj1 = 0 ;
39814 char *kwnames[] = {
39815 (char *) "self",(char *) "item", NULL
39816 };
39817
39818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39820 if (SWIG_arg_fail(1)) SWIG_fail;
39821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39822 if (SWIG_arg_fail(2)) SWIG_fail;
39823 {
39824 PyThreadState* __tstate = wxPyBeginAllowThreads();
39825 result = (wxSizerItem *)(arg1)->Add(arg2);
39826
39827 wxPyEndAllowThreads(__tstate);
39828 if (PyErr_Occurred()) SWIG_fail;
39829 }
39830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39831 return resultobj;
39832 fail:
39833 return NULL;
39834 }
39835
39836
39837 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39838 PyObject *resultobj;
39839 wxSizer *arg1 = (wxSizer *) 0 ;
39840 size_t arg2 ;
39841 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39842 wxSizerItem *result;
39843 PyObject * obj0 = 0 ;
39844 PyObject * obj1 = 0 ;
39845 PyObject * obj2 = 0 ;
39846 char *kwnames[] = {
39847 (char *) "self",(char *) "index",(char *) "item", NULL
39848 };
39849
39850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39852 if (SWIG_arg_fail(1)) SWIG_fail;
39853 {
39854 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39855 if (SWIG_arg_fail(2)) SWIG_fail;
39856 }
39857 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39858 if (SWIG_arg_fail(3)) SWIG_fail;
39859 {
39860 PyThreadState* __tstate = wxPyBeginAllowThreads();
39861 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39862
39863 wxPyEndAllowThreads(__tstate);
39864 if (PyErr_Occurred()) SWIG_fail;
39865 }
39866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39867 return resultobj;
39868 fail:
39869 return NULL;
39870 }
39871
39872
39873 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39874 PyObject *resultobj;
39875 wxSizer *arg1 = (wxSizer *) 0 ;
39876 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39877 wxSizerItem *result;
39878 PyObject * obj0 = 0 ;
39879 PyObject * obj1 = 0 ;
39880 char *kwnames[] = {
39881 (char *) "self",(char *) "item", NULL
39882 };
39883
39884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39886 if (SWIG_arg_fail(1)) SWIG_fail;
39887 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39888 if (SWIG_arg_fail(2)) SWIG_fail;
39889 {
39890 PyThreadState* __tstate = wxPyBeginAllowThreads();
39891 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39892
39893 wxPyEndAllowThreads(__tstate);
39894 if (PyErr_Occurred()) SWIG_fail;
39895 }
39896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39897 return resultobj;
39898 fail:
39899 return NULL;
39900 }
39901
39902
39903 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39904 PyObject *resultobj;
39905 wxSizer *arg1 = (wxSizer *) 0 ;
39906 int arg2 ;
39907 int arg3 ;
39908 int arg4 ;
39909 int arg5 ;
39910 PyObject * obj0 = 0 ;
39911 PyObject * obj1 = 0 ;
39912 PyObject * obj2 = 0 ;
39913 PyObject * obj3 = 0 ;
39914 PyObject * obj4 = 0 ;
39915 char *kwnames[] = {
39916 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39917 };
39918
39919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39921 if (SWIG_arg_fail(1)) SWIG_fail;
39922 {
39923 arg2 = (int)(SWIG_As_int(obj1));
39924 if (SWIG_arg_fail(2)) SWIG_fail;
39925 }
39926 {
39927 arg3 = (int)(SWIG_As_int(obj2));
39928 if (SWIG_arg_fail(3)) SWIG_fail;
39929 }
39930 {
39931 arg4 = (int)(SWIG_As_int(obj3));
39932 if (SWIG_arg_fail(4)) SWIG_fail;
39933 }
39934 {
39935 arg5 = (int)(SWIG_As_int(obj4));
39936 if (SWIG_arg_fail(5)) SWIG_fail;
39937 }
39938 {
39939 PyThreadState* __tstate = wxPyBeginAllowThreads();
39940 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39941
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 Py_INCREF(Py_None); resultobj = Py_None;
39946 return resultobj;
39947 fail:
39948 return NULL;
39949 }
39950
39951
39952 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39953 PyObject *resultobj;
39954 wxSizer *arg1 = (wxSizer *) 0 ;
39955 wxSize *arg2 = 0 ;
39956 wxSize temp2 ;
39957 PyObject * obj0 = 0 ;
39958 PyObject * obj1 = 0 ;
39959 char *kwnames[] = {
39960 (char *) "self",(char *) "size", NULL
39961 };
39962
39963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39965 if (SWIG_arg_fail(1)) SWIG_fail;
39966 {
39967 arg2 = &temp2;
39968 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39969 }
39970 {
39971 PyThreadState* __tstate = wxPyBeginAllowThreads();
39972 (arg1)->SetMinSize((wxSize const &)*arg2);
39973
39974 wxPyEndAllowThreads(__tstate);
39975 if (PyErr_Occurred()) SWIG_fail;
39976 }
39977 Py_INCREF(Py_None); resultobj = Py_None;
39978 return resultobj;
39979 fail:
39980 return NULL;
39981 }
39982
39983
39984 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39985 PyObject *resultobj;
39986 wxSizer *arg1 = (wxSizer *) 0 ;
39987 wxSize result;
39988 PyObject * obj0 = 0 ;
39989 char *kwnames[] = {
39990 (char *) "self", NULL
39991 };
39992
39993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39995 if (SWIG_arg_fail(1)) SWIG_fail;
39996 {
39997 PyThreadState* __tstate = wxPyBeginAllowThreads();
39998 result = (arg1)->GetSize();
39999
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 {
40004 wxSize * resultptr;
40005 resultptr = new wxSize((wxSize &)(result));
40006 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40007 }
40008 return resultobj;
40009 fail:
40010 return NULL;
40011 }
40012
40013
40014 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40015 PyObject *resultobj;
40016 wxSizer *arg1 = (wxSizer *) 0 ;
40017 wxPoint result;
40018 PyObject * obj0 = 0 ;
40019 char *kwnames[] = {
40020 (char *) "self", NULL
40021 };
40022
40023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40025 if (SWIG_arg_fail(1)) SWIG_fail;
40026 {
40027 PyThreadState* __tstate = wxPyBeginAllowThreads();
40028 result = (arg1)->GetPosition();
40029
40030 wxPyEndAllowThreads(__tstate);
40031 if (PyErr_Occurred()) SWIG_fail;
40032 }
40033 {
40034 wxPoint * resultptr;
40035 resultptr = new wxPoint((wxPoint &)(result));
40036 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40037 }
40038 return resultobj;
40039 fail:
40040 return NULL;
40041 }
40042
40043
40044 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40045 PyObject *resultobj;
40046 wxSizer *arg1 = (wxSizer *) 0 ;
40047 wxSize result;
40048 PyObject * obj0 = 0 ;
40049 char *kwnames[] = {
40050 (char *) "self", NULL
40051 };
40052
40053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40055 if (SWIG_arg_fail(1)) SWIG_fail;
40056 {
40057 PyThreadState* __tstate = wxPyBeginAllowThreads();
40058 result = (arg1)->GetMinSize();
40059
40060 wxPyEndAllowThreads(__tstate);
40061 if (PyErr_Occurred()) SWIG_fail;
40062 }
40063 {
40064 wxSize * resultptr;
40065 resultptr = new wxSize((wxSize &)(result));
40066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40067 }
40068 return resultobj;
40069 fail:
40070 return NULL;
40071 }
40072
40073
40074 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40075 PyObject *resultobj;
40076 wxSizer *arg1 = (wxSizer *) 0 ;
40077 PyObject * obj0 = 0 ;
40078 char *kwnames[] = {
40079 (char *) "self", NULL
40080 };
40081
40082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40084 if (SWIG_arg_fail(1)) SWIG_fail;
40085 {
40086 PyThreadState* __tstate = wxPyBeginAllowThreads();
40087 (arg1)->RecalcSizes();
40088
40089 wxPyEndAllowThreads(__tstate);
40090 if (PyErr_Occurred()) SWIG_fail;
40091 }
40092 Py_INCREF(Py_None); resultobj = Py_None;
40093 return resultobj;
40094 fail:
40095 return NULL;
40096 }
40097
40098
40099 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40100 PyObject *resultobj;
40101 wxSizer *arg1 = (wxSizer *) 0 ;
40102 wxSize result;
40103 PyObject * obj0 = 0 ;
40104 char *kwnames[] = {
40105 (char *) "self", NULL
40106 };
40107
40108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40110 if (SWIG_arg_fail(1)) SWIG_fail;
40111 {
40112 PyThreadState* __tstate = wxPyBeginAllowThreads();
40113 result = (arg1)->CalcMin();
40114
40115 wxPyEndAllowThreads(__tstate);
40116 if (PyErr_Occurred()) SWIG_fail;
40117 }
40118 {
40119 wxSize * resultptr;
40120 resultptr = new wxSize((wxSize &)(result));
40121 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40122 }
40123 return resultobj;
40124 fail:
40125 return NULL;
40126 }
40127
40128
40129 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40130 PyObject *resultobj;
40131 wxSizer *arg1 = (wxSizer *) 0 ;
40132 PyObject * obj0 = 0 ;
40133 char *kwnames[] = {
40134 (char *) "self", NULL
40135 };
40136
40137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40139 if (SWIG_arg_fail(1)) SWIG_fail;
40140 {
40141 PyThreadState* __tstate = wxPyBeginAllowThreads();
40142 (arg1)->Layout();
40143
40144 wxPyEndAllowThreads(__tstate);
40145 if (PyErr_Occurred()) SWIG_fail;
40146 }
40147 Py_INCREF(Py_None); resultobj = Py_None;
40148 return resultobj;
40149 fail:
40150 return NULL;
40151 }
40152
40153
40154 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40155 PyObject *resultobj;
40156 wxSizer *arg1 = (wxSizer *) 0 ;
40157 wxWindow *arg2 = (wxWindow *) 0 ;
40158 wxSize result;
40159 PyObject * obj0 = 0 ;
40160 PyObject * obj1 = 0 ;
40161 char *kwnames[] = {
40162 (char *) "self",(char *) "window", NULL
40163 };
40164
40165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40167 if (SWIG_arg_fail(1)) SWIG_fail;
40168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40169 if (SWIG_arg_fail(2)) SWIG_fail;
40170 {
40171 PyThreadState* __tstate = wxPyBeginAllowThreads();
40172 result = (arg1)->Fit(arg2);
40173
40174 wxPyEndAllowThreads(__tstate);
40175 if (PyErr_Occurred()) SWIG_fail;
40176 }
40177 {
40178 wxSize * resultptr;
40179 resultptr = new wxSize((wxSize &)(result));
40180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40181 }
40182 return resultobj;
40183 fail:
40184 return NULL;
40185 }
40186
40187
40188 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40189 PyObject *resultobj;
40190 wxSizer *arg1 = (wxSizer *) 0 ;
40191 wxWindow *arg2 = (wxWindow *) 0 ;
40192 PyObject * obj0 = 0 ;
40193 PyObject * obj1 = 0 ;
40194 char *kwnames[] = {
40195 (char *) "self",(char *) "window", NULL
40196 };
40197
40198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40200 if (SWIG_arg_fail(1)) SWIG_fail;
40201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40202 if (SWIG_arg_fail(2)) SWIG_fail;
40203 {
40204 PyThreadState* __tstate = wxPyBeginAllowThreads();
40205 (arg1)->FitInside(arg2);
40206
40207 wxPyEndAllowThreads(__tstate);
40208 if (PyErr_Occurred()) SWIG_fail;
40209 }
40210 Py_INCREF(Py_None); resultobj = Py_None;
40211 return resultobj;
40212 fail:
40213 return NULL;
40214 }
40215
40216
40217 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40218 PyObject *resultobj;
40219 wxSizer *arg1 = (wxSizer *) 0 ;
40220 wxWindow *arg2 = (wxWindow *) 0 ;
40221 PyObject * obj0 = 0 ;
40222 PyObject * obj1 = 0 ;
40223 char *kwnames[] = {
40224 (char *) "self",(char *) "window", NULL
40225 };
40226
40227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40229 if (SWIG_arg_fail(1)) SWIG_fail;
40230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40231 if (SWIG_arg_fail(2)) SWIG_fail;
40232 {
40233 PyThreadState* __tstate = wxPyBeginAllowThreads();
40234 (arg1)->SetSizeHints(arg2);
40235
40236 wxPyEndAllowThreads(__tstate);
40237 if (PyErr_Occurred()) SWIG_fail;
40238 }
40239 Py_INCREF(Py_None); resultobj = Py_None;
40240 return resultobj;
40241 fail:
40242 return NULL;
40243 }
40244
40245
40246 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40247 PyObject *resultobj;
40248 wxSizer *arg1 = (wxSizer *) 0 ;
40249 wxWindow *arg2 = (wxWindow *) 0 ;
40250 PyObject * obj0 = 0 ;
40251 PyObject * obj1 = 0 ;
40252 char *kwnames[] = {
40253 (char *) "self",(char *) "window", NULL
40254 };
40255
40256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40258 if (SWIG_arg_fail(1)) SWIG_fail;
40259 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40260 if (SWIG_arg_fail(2)) SWIG_fail;
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 (arg1)->SetVirtualSizeHints(arg2);
40264
40265 wxPyEndAllowThreads(__tstate);
40266 if (PyErr_Occurred()) SWIG_fail;
40267 }
40268 Py_INCREF(Py_None); resultobj = Py_None;
40269 return resultobj;
40270 fail:
40271 return NULL;
40272 }
40273
40274
40275 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40276 PyObject *resultobj;
40277 wxSizer *arg1 = (wxSizer *) 0 ;
40278 bool arg2 = (bool) false ;
40279 PyObject * obj0 = 0 ;
40280 PyObject * obj1 = 0 ;
40281 char *kwnames[] = {
40282 (char *) "self",(char *) "deleteWindows", NULL
40283 };
40284
40285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40287 if (SWIG_arg_fail(1)) SWIG_fail;
40288 if (obj1) {
40289 {
40290 arg2 = (bool)(SWIG_As_bool(obj1));
40291 if (SWIG_arg_fail(2)) SWIG_fail;
40292 }
40293 }
40294 {
40295 PyThreadState* __tstate = wxPyBeginAllowThreads();
40296 (arg1)->Clear(arg2);
40297
40298 wxPyEndAllowThreads(__tstate);
40299 if (PyErr_Occurred()) SWIG_fail;
40300 }
40301 Py_INCREF(Py_None); resultobj = Py_None;
40302 return resultobj;
40303 fail:
40304 return NULL;
40305 }
40306
40307
40308 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40309 PyObject *resultobj;
40310 wxSizer *arg1 = (wxSizer *) 0 ;
40311 PyObject * obj0 = 0 ;
40312 char *kwnames[] = {
40313 (char *) "self", NULL
40314 };
40315
40316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40318 if (SWIG_arg_fail(1)) SWIG_fail;
40319 {
40320 PyThreadState* __tstate = wxPyBeginAllowThreads();
40321 (arg1)->DeleteWindows();
40322
40323 wxPyEndAllowThreads(__tstate);
40324 if (PyErr_Occurred()) SWIG_fail;
40325 }
40326 Py_INCREF(Py_None); resultobj = Py_None;
40327 return resultobj;
40328 fail:
40329 return NULL;
40330 }
40331
40332
40333 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40334 PyObject *resultobj;
40335 wxSizer *arg1 = (wxSizer *) 0 ;
40336 PyObject *result;
40337 PyObject * obj0 = 0 ;
40338 char *kwnames[] = {
40339 (char *) "self", NULL
40340 };
40341
40342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40344 if (SWIG_arg_fail(1)) SWIG_fail;
40345 {
40346 PyThreadState* __tstate = wxPyBeginAllowThreads();
40347 result = (PyObject *)wxSizer_GetChildren(arg1);
40348
40349 wxPyEndAllowThreads(__tstate);
40350 if (PyErr_Occurred()) SWIG_fail;
40351 }
40352 resultobj = result;
40353 return resultobj;
40354 fail:
40355 return NULL;
40356 }
40357
40358
40359 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40360 PyObject *resultobj;
40361 wxSizer *arg1 = (wxSizer *) 0 ;
40362 PyObject *arg2 = (PyObject *) 0 ;
40363 bool arg3 = (bool) true ;
40364 bool arg4 = (bool) false ;
40365 bool result;
40366 PyObject * obj0 = 0 ;
40367 PyObject * obj1 = 0 ;
40368 PyObject * obj2 = 0 ;
40369 PyObject * obj3 = 0 ;
40370 char *kwnames[] = {
40371 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40372 };
40373
40374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40376 if (SWIG_arg_fail(1)) SWIG_fail;
40377 arg2 = obj1;
40378 if (obj2) {
40379 {
40380 arg3 = (bool)(SWIG_As_bool(obj2));
40381 if (SWIG_arg_fail(3)) SWIG_fail;
40382 }
40383 }
40384 if (obj3) {
40385 {
40386 arg4 = (bool)(SWIG_As_bool(obj3));
40387 if (SWIG_arg_fail(4)) SWIG_fail;
40388 }
40389 }
40390 {
40391 PyThreadState* __tstate = wxPyBeginAllowThreads();
40392 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40393
40394 wxPyEndAllowThreads(__tstate);
40395 if (PyErr_Occurred()) SWIG_fail;
40396 }
40397 {
40398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40399 }
40400 return resultobj;
40401 fail:
40402 return NULL;
40403 }
40404
40405
40406 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40407 PyObject *resultobj;
40408 wxSizer *arg1 = (wxSizer *) 0 ;
40409 PyObject *arg2 = (PyObject *) 0 ;
40410 bool result;
40411 PyObject * obj0 = 0 ;
40412 PyObject * obj1 = 0 ;
40413 char *kwnames[] = {
40414 (char *) "self",(char *) "item", NULL
40415 };
40416
40417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40419 if (SWIG_arg_fail(1)) SWIG_fail;
40420 arg2 = obj1;
40421 {
40422 PyThreadState* __tstate = wxPyBeginAllowThreads();
40423 result = (bool)wxSizer_IsShown(arg1,arg2);
40424
40425 wxPyEndAllowThreads(__tstate);
40426 if (PyErr_Occurred()) SWIG_fail;
40427 }
40428 {
40429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40430 }
40431 return resultobj;
40432 fail:
40433 return NULL;
40434 }
40435
40436
40437 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40438 PyObject *resultobj;
40439 wxSizer *arg1 = (wxSizer *) 0 ;
40440 bool arg2 ;
40441 PyObject * obj0 = 0 ;
40442 PyObject * obj1 = 0 ;
40443 char *kwnames[] = {
40444 (char *) "self",(char *) "show", NULL
40445 };
40446
40447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40449 if (SWIG_arg_fail(1)) SWIG_fail;
40450 {
40451 arg2 = (bool)(SWIG_As_bool(obj1));
40452 if (SWIG_arg_fail(2)) SWIG_fail;
40453 }
40454 {
40455 PyThreadState* __tstate = wxPyBeginAllowThreads();
40456 (arg1)->ShowItems(arg2);
40457
40458 wxPyEndAllowThreads(__tstate);
40459 if (PyErr_Occurred()) SWIG_fail;
40460 }
40461 Py_INCREF(Py_None); resultobj = Py_None;
40462 return resultobj;
40463 fail:
40464 return NULL;
40465 }
40466
40467
40468 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40469 PyObject *obj;
40470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40471 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40472 Py_INCREF(obj);
40473 return Py_BuildValue((char *)"");
40474 }
40475 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40476 PyObject *resultobj;
40477 wxPySizer *result;
40478 char *kwnames[] = {
40479 NULL
40480 };
40481
40482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40483 {
40484 PyThreadState* __tstate = wxPyBeginAllowThreads();
40485 result = (wxPySizer *)new wxPySizer();
40486
40487 wxPyEndAllowThreads(__tstate);
40488 if (PyErr_Occurred()) SWIG_fail;
40489 }
40490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40491 return resultobj;
40492 fail:
40493 return NULL;
40494 }
40495
40496
40497 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40498 PyObject *resultobj;
40499 wxPySizer *arg1 = (wxPySizer *) 0 ;
40500 PyObject *arg2 = (PyObject *) 0 ;
40501 PyObject *arg3 = (PyObject *) 0 ;
40502 PyObject * obj0 = 0 ;
40503 PyObject * obj1 = 0 ;
40504 PyObject * obj2 = 0 ;
40505 char *kwnames[] = {
40506 (char *) "self",(char *) "self",(char *) "_class", NULL
40507 };
40508
40509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40511 if (SWIG_arg_fail(1)) SWIG_fail;
40512 arg2 = obj1;
40513 arg3 = obj2;
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 (arg1)->_setCallbackInfo(arg2,arg3);
40517
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 Py_INCREF(Py_None); resultobj = Py_None;
40522 return resultobj;
40523 fail:
40524 return NULL;
40525 }
40526
40527
40528 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40529 PyObject *obj;
40530 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40531 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40532 Py_INCREF(obj);
40533 return Py_BuildValue((char *)"");
40534 }
40535 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40536 PyObject *resultobj;
40537 int arg1 = (int) wxHORIZONTAL ;
40538 wxBoxSizer *result;
40539 PyObject * obj0 = 0 ;
40540 char *kwnames[] = {
40541 (char *) "orient", NULL
40542 };
40543
40544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40545 if (obj0) {
40546 {
40547 arg1 = (int)(SWIG_As_int(obj0));
40548 if (SWIG_arg_fail(1)) SWIG_fail;
40549 }
40550 }
40551 {
40552 PyThreadState* __tstate = wxPyBeginAllowThreads();
40553 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40554
40555 wxPyEndAllowThreads(__tstate);
40556 if (PyErr_Occurred()) SWIG_fail;
40557 }
40558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40559 return resultobj;
40560 fail:
40561 return NULL;
40562 }
40563
40564
40565 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40566 PyObject *resultobj;
40567 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40568 int result;
40569 PyObject * obj0 = 0 ;
40570 char *kwnames[] = {
40571 (char *) "self", NULL
40572 };
40573
40574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40576 if (SWIG_arg_fail(1)) SWIG_fail;
40577 {
40578 PyThreadState* __tstate = wxPyBeginAllowThreads();
40579 result = (int)(arg1)->GetOrientation();
40580
40581 wxPyEndAllowThreads(__tstate);
40582 if (PyErr_Occurred()) SWIG_fail;
40583 }
40584 {
40585 resultobj = SWIG_From_int((int)(result));
40586 }
40587 return resultobj;
40588 fail:
40589 return NULL;
40590 }
40591
40592
40593 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40594 PyObject *resultobj;
40595 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40596 int arg2 ;
40597 PyObject * obj0 = 0 ;
40598 PyObject * obj1 = 0 ;
40599 char *kwnames[] = {
40600 (char *) "self",(char *) "orient", NULL
40601 };
40602
40603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40605 if (SWIG_arg_fail(1)) SWIG_fail;
40606 {
40607 arg2 = (int)(SWIG_As_int(obj1));
40608 if (SWIG_arg_fail(2)) SWIG_fail;
40609 }
40610 {
40611 PyThreadState* __tstate = wxPyBeginAllowThreads();
40612 (arg1)->SetOrientation(arg2);
40613
40614 wxPyEndAllowThreads(__tstate);
40615 if (PyErr_Occurred()) SWIG_fail;
40616 }
40617 Py_INCREF(Py_None); resultobj = Py_None;
40618 return resultobj;
40619 fail:
40620 return NULL;
40621 }
40622
40623
40624 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40625 PyObject *obj;
40626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40627 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40628 Py_INCREF(obj);
40629 return Py_BuildValue((char *)"");
40630 }
40631 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40632 PyObject *resultobj;
40633 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40634 int arg2 = (int) wxHORIZONTAL ;
40635 wxStaticBoxSizer *result;
40636 PyObject * obj0 = 0 ;
40637 PyObject * obj1 = 0 ;
40638 char *kwnames[] = {
40639 (char *) "box",(char *) "orient", NULL
40640 };
40641
40642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40644 if (SWIG_arg_fail(1)) SWIG_fail;
40645 if (obj1) {
40646 {
40647 arg2 = (int)(SWIG_As_int(obj1));
40648 if (SWIG_arg_fail(2)) SWIG_fail;
40649 }
40650 }
40651 {
40652 PyThreadState* __tstate = wxPyBeginAllowThreads();
40653 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40654
40655 wxPyEndAllowThreads(__tstate);
40656 if (PyErr_Occurred()) SWIG_fail;
40657 }
40658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40659 return resultobj;
40660 fail:
40661 return NULL;
40662 }
40663
40664
40665 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40666 PyObject *resultobj;
40667 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40668 wxStaticBox *result;
40669 PyObject * obj0 = 0 ;
40670 char *kwnames[] = {
40671 (char *) "self", NULL
40672 };
40673
40674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40676 if (SWIG_arg_fail(1)) SWIG_fail;
40677 {
40678 PyThreadState* __tstate = wxPyBeginAllowThreads();
40679 result = (wxStaticBox *)(arg1)->GetStaticBox();
40680
40681 wxPyEndAllowThreads(__tstate);
40682 if (PyErr_Occurred()) SWIG_fail;
40683 }
40684 {
40685 resultobj = wxPyMake_wxObject(result, 0);
40686 }
40687 return resultobj;
40688 fail:
40689 return NULL;
40690 }
40691
40692
40693 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40694 PyObject *obj;
40695 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40696 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40697 Py_INCREF(obj);
40698 return Py_BuildValue((char *)"");
40699 }
40700 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40701 PyObject *resultobj;
40702 int arg1 = (int) 1 ;
40703 int arg2 = (int) 0 ;
40704 int arg3 = (int) 0 ;
40705 int arg4 = (int) 0 ;
40706 wxGridSizer *result;
40707 PyObject * obj0 = 0 ;
40708 PyObject * obj1 = 0 ;
40709 PyObject * obj2 = 0 ;
40710 PyObject * obj3 = 0 ;
40711 char *kwnames[] = {
40712 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40713 };
40714
40715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40716 if (obj0) {
40717 {
40718 arg1 = (int)(SWIG_As_int(obj0));
40719 if (SWIG_arg_fail(1)) SWIG_fail;
40720 }
40721 }
40722 if (obj1) {
40723 {
40724 arg2 = (int)(SWIG_As_int(obj1));
40725 if (SWIG_arg_fail(2)) SWIG_fail;
40726 }
40727 }
40728 if (obj2) {
40729 {
40730 arg3 = (int)(SWIG_As_int(obj2));
40731 if (SWIG_arg_fail(3)) SWIG_fail;
40732 }
40733 }
40734 if (obj3) {
40735 {
40736 arg4 = (int)(SWIG_As_int(obj3));
40737 if (SWIG_arg_fail(4)) SWIG_fail;
40738 }
40739 }
40740 {
40741 PyThreadState* __tstate = wxPyBeginAllowThreads();
40742 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40743
40744 wxPyEndAllowThreads(__tstate);
40745 if (PyErr_Occurred()) SWIG_fail;
40746 }
40747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40748 return resultobj;
40749 fail:
40750 return NULL;
40751 }
40752
40753
40754 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40755 PyObject *resultobj;
40756 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40757 int arg2 ;
40758 PyObject * obj0 = 0 ;
40759 PyObject * obj1 = 0 ;
40760 char *kwnames[] = {
40761 (char *) "self",(char *) "cols", NULL
40762 };
40763
40764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40766 if (SWIG_arg_fail(1)) SWIG_fail;
40767 {
40768 arg2 = (int)(SWIG_As_int(obj1));
40769 if (SWIG_arg_fail(2)) SWIG_fail;
40770 }
40771 {
40772 PyThreadState* __tstate = wxPyBeginAllowThreads();
40773 (arg1)->SetCols(arg2);
40774
40775 wxPyEndAllowThreads(__tstate);
40776 if (PyErr_Occurred()) SWIG_fail;
40777 }
40778 Py_INCREF(Py_None); resultobj = Py_None;
40779 return resultobj;
40780 fail:
40781 return NULL;
40782 }
40783
40784
40785 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40786 PyObject *resultobj;
40787 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40788 int arg2 ;
40789 PyObject * obj0 = 0 ;
40790 PyObject * obj1 = 0 ;
40791 char *kwnames[] = {
40792 (char *) "self",(char *) "rows", NULL
40793 };
40794
40795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40797 if (SWIG_arg_fail(1)) SWIG_fail;
40798 {
40799 arg2 = (int)(SWIG_As_int(obj1));
40800 if (SWIG_arg_fail(2)) SWIG_fail;
40801 }
40802 {
40803 PyThreadState* __tstate = wxPyBeginAllowThreads();
40804 (arg1)->SetRows(arg2);
40805
40806 wxPyEndAllowThreads(__tstate);
40807 if (PyErr_Occurred()) SWIG_fail;
40808 }
40809 Py_INCREF(Py_None); resultobj = Py_None;
40810 return resultobj;
40811 fail:
40812 return NULL;
40813 }
40814
40815
40816 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40817 PyObject *resultobj;
40818 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40819 int arg2 ;
40820 PyObject * obj0 = 0 ;
40821 PyObject * obj1 = 0 ;
40822 char *kwnames[] = {
40823 (char *) "self",(char *) "gap", NULL
40824 };
40825
40826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40828 if (SWIG_arg_fail(1)) SWIG_fail;
40829 {
40830 arg2 = (int)(SWIG_As_int(obj1));
40831 if (SWIG_arg_fail(2)) SWIG_fail;
40832 }
40833 {
40834 PyThreadState* __tstate = wxPyBeginAllowThreads();
40835 (arg1)->SetVGap(arg2);
40836
40837 wxPyEndAllowThreads(__tstate);
40838 if (PyErr_Occurred()) SWIG_fail;
40839 }
40840 Py_INCREF(Py_None); resultobj = Py_None;
40841 return resultobj;
40842 fail:
40843 return NULL;
40844 }
40845
40846
40847 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40848 PyObject *resultobj;
40849 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40850 int arg2 ;
40851 PyObject * obj0 = 0 ;
40852 PyObject * obj1 = 0 ;
40853 char *kwnames[] = {
40854 (char *) "self",(char *) "gap", NULL
40855 };
40856
40857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40859 if (SWIG_arg_fail(1)) SWIG_fail;
40860 {
40861 arg2 = (int)(SWIG_As_int(obj1));
40862 if (SWIG_arg_fail(2)) SWIG_fail;
40863 }
40864 {
40865 PyThreadState* __tstate = wxPyBeginAllowThreads();
40866 (arg1)->SetHGap(arg2);
40867
40868 wxPyEndAllowThreads(__tstate);
40869 if (PyErr_Occurred()) SWIG_fail;
40870 }
40871 Py_INCREF(Py_None); resultobj = Py_None;
40872 return resultobj;
40873 fail:
40874 return NULL;
40875 }
40876
40877
40878 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40879 PyObject *resultobj;
40880 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40881 int result;
40882 PyObject * obj0 = 0 ;
40883 char *kwnames[] = {
40884 (char *) "self", NULL
40885 };
40886
40887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40889 if (SWIG_arg_fail(1)) SWIG_fail;
40890 {
40891 PyThreadState* __tstate = wxPyBeginAllowThreads();
40892 result = (int)(arg1)->GetCols();
40893
40894 wxPyEndAllowThreads(__tstate);
40895 if (PyErr_Occurred()) SWIG_fail;
40896 }
40897 {
40898 resultobj = SWIG_From_int((int)(result));
40899 }
40900 return resultobj;
40901 fail:
40902 return NULL;
40903 }
40904
40905
40906 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40907 PyObject *resultobj;
40908 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40909 int result;
40910 PyObject * obj0 = 0 ;
40911 char *kwnames[] = {
40912 (char *) "self", NULL
40913 };
40914
40915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40917 if (SWIG_arg_fail(1)) SWIG_fail;
40918 {
40919 PyThreadState* __tstate = wxPyBeginAllowThreads();
40920 result = (int)(arg1)->GetRows();
40921
40922 wxPyEndAllowThreads(__tstate);
40923 if (PyErr_Occurred()) SWIG_fail;
40924 }
40925 {
40926 resultobj = SWIG_From_int((int)(result));
40927 }
40928 return resultobj;
40929 fail:
40930 return NULL;
40931 }
40932
40933
40934 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40935 PyObject *resultobj;
40936 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40937 int result;
40938 PyObject * obj0 = 0 ;
40939 char *kwnames[] = {
40940 (char *) "self", NULL
40941 };
40942
40943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40945 if (SWIG_arg_fail(1)) SWIG_fail;
40946 {
40947 PyThreadState* __tstate = wxPyBeginAllowThreads();
40948 result = (int)(arg1)->GetVGap();
40949
40950 wxPyEndAllowThreads(__tstate);
40951 if (PyErr_Occurred()) SWIG_fail;
40952 }
40953 {
40954 resultobj = SWIG_From_int((int)(result));
40955 }
40956 return resultobj;
40957 fail:
40958 return NULL;
40959 }
40960
40961
40962 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40963 PyObject *resultobj;
40964 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40965 int result;
40966 PyObject * obj0 = 0 ;
40967 char *kwnames[] = {
40968 (char *) "self", NULL
40969 };
40970
40971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40973 if (SWIG_arg_fail(1)) SWIG_fail;
40974 {
40975 PyThreadState* __tstate = wxPyBeginAllowThreads();
40976 result = (int)(arg1)->GetHGap();
40977
40978 wxPyEndAllowThreads(__tstate);
40979 if (PyErr_Occurred()) SWIG_fail;
40980 }
40981 {
40982 resultobj = SWIG_From_int((int)(result));
40983 }
40984 return resultobj;
40985 fail:
40986 return NULL;
40987 }
40988
40989
40990 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40991 PyObject *obj;
40992 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40993 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40994 Py_INCREF(obj);
40995 return Py_BuildValue((char *)"");
40996 }
40997 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40998 PyObject *resultobj;
40999 int arg1 = (int) 1 ;
41000 int arg2 = (int) 0 ;
41001 int arg3 = (int) 0 ;
41002 int arg4 = (int) 0 ;
41003 wxFlexGridSizer *result;
41004 PyObject * obj0 = 0 ;
41005 PyObject * obj1 = 0 ;
41006 PyObject * obj2 = 0 ;
41007 PyObject * obj3 = 0 ;
41008 char *kwnames[] = {
41009 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41010 };
41011
41012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41013 if (obj0) {
41014 {
41015 arg1 = (int)(SWIG_As_int(obj0));
41016 if (SWIG_arg_fail(1)) SWIG_fail;
41017 }
41018 }
41019 if (obj1) {
41020 {
41021 arg2 = (int)(SWIG_As_int(obj1));
41022 if (SWIG_arg_fail(2)) SWIG_fail;
41023 }
41024 }
41025 if (obj2) {
41026 {
41027 arg3 = (int)(SWIG_As_int(obj2));
41028 if (SWIG_arg_fail(3)) SWIG_fail;
41029 }
41030 }
41031 if (obj3) {
41032 {
41033 arg4 = (int)(SWIG_As_int(obj3));
41034 if (SWIG_arg_fail(4)) SWIG_fail;
41035 }
41036 }
41037 {
41038 PyThreadState* __tstate = wxPyBeginAllowThreads();
41039 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41040
41041 wxPyEndAllowThreads(__tstate);
41042 if (PyErr_Occurred()) SWIG_fail;
41043 }
41044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41045 return resultobj;
41046 fail:
41047 return NULL;
41048 }
41049
41050
41051 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41052 PyObject *resultobj;
41053 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41054 size_t arg2 ;
41055 int arg3 = (int) 0 ;
41056 PyObject * obj0 = 0 ;
41057 PyObject * obj1 = 0 ;
41058 PyObject * obj2 = 0 ;
41059 char *kwnames[] = {
41060 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41061 };
41062
41063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41065 if (SWIG_arg_fail(1)) SWIG_fail;
41066 {
41067 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41068 if (SWIG_arg_fail(2)) SWIG_fail;
41069 }
41070 if (obj2) {
41071 {
41072 arg3 = (int)(SWIG_As_int(obj2));
41073 if (SWIG_arg_fail(3)) SWIG_fail;
41074 }
41075 }
41076 {
41077 PyThreadState* __tstate = wxPyBeginAllowThreads();
41078 (arg1)->AddGrowableRow(arg2,arg3);
41079
41080 wxPyEndAllowThreads(__tstate);
41081 if (PyErr_Occurred()) SWIG_fail;
41082 }
41083 Py_INCREF(Py_None); resultobj = Py_None;
41084 return resultobj;
41085 fail:
41086 return NULL;
41087 }
41088
41089
41090 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41091 PyObject *resultobj;
41092 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41093 size_t arg2 ;
41094 PyObject * obj0 = 0 ;
41095 PyObject * obj1 = 0 ;
41096 char *kwnames[] = {
41097 (char *) "self",(char *) "idx", NULL
41098 };
41099
41100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41102 if (SWIG_arg_fail(1)) SWIG_fail;
41103 {
41104 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41105 if (SWIG_arg_fail(2)) SWIG_fail;
41106 }
41107 {
41108 PyThreadState* __tstate = wxPyBeginAllowThreads();
41109 (arg1)->RemoveGrowableRow(arg2);
41110
41111 wxPyEndAllowThreads(__tstate);
41112 if (PyErr_Occurred()) SWIG_fail;
41113 }
41114 Py_INCREF(Py_None); resultobj = Py_None;
41115 return resultobj;
41116 fail:
41117 return NULL;
41118 }
41119
41120
41121 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41122 PyObject *resultobj;
41123 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41124 size_t arg2 ;
41125 int arg3 = (int) 0 ;
41126 PyObject * obj0 = 0 ;
41127 PyObject * obj1 = 0 ;
41128 PyObject * obj2 = 0 ;
41129 char *kwnames[] = {
41130 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41131 };
41132
41133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41135 if (SWIG_arg_fail(1)) SWIG_fail;
41136 {
41137 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41138 if (SWIG_arg_fail(2)) SWIG_fail;
41139 }
41140 if (obj2) {
41141 {
41142 arg3 = (int)(SWIG_As_int(obj2));
41143 if (SWIG_arg_fail(3)) SWIG_fail;
41144 }
41145 }
41146 {
41147 PyThreadState* __tstate = wxPyBeginAllowThreads();
41148 (arg1)->AddGrowableCol(arg2,arg3);
41149
41150 wxPyEndAllowThreads(__tstate);
41151 if (PyErr_Occurred()) SWIG_fail;
41152 }
41153 Py_INCREF(Py_None); resultobj = Py_None;
41154 return resultobj;
41155 fail:
41156 return NULL;
41157 }
41158
41159
41160 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41161 PyObject *resultobj;
41162 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41163 size_t arg2 ;
41164 PyObject * obj0 = 0 ;
41165 PyObject * obj1 = 0 ;
41166 char *kwnames[] = {
41167 (char *) "self",(char *) "idx", NULL
41168 };
41169
41170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41172 if (SWIG_arg_fail(1)) SWIG_fail;
41173 {
41174 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41175 if (SWIG_arg_fail(2)) SWIG_fail;
41176 }
41177 {
41178 PyThreadState* __tstate = wxPyBeginAllowThreads();
41179 (arg1)->RemoveGrowableCol(arg2);
41180
41181 wxPyEndAllowThreads(__tstate);
41182 if (PyErr_Occurred()) SWIG_fail;
41183 }
41184 Py_INCREF(Py_None); resultobj = Py_None;
41185 return resultobj;
41186 fail:
41187 return NULL;
41188 }
41189
41190
41191 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41192 PyObject *resultobj;
41193 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41194 int arg2 ;
41195 PyObject * obj0 = 0 ;
41196 PyObject * obj1 = 0 ;
41197 char *kwnames[] = {
41198 (char *) "self",(char *) "direction", NULL
41199 };
41200
41201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41203 if (SWIG_arg_fail(1)) SWIG_fail;
41204 {
41205 arg2 = (int)(SWIG_As_int(obj1));
41206 if (SWIG_arg_fail(2)) SWIG_fail;
41207 }
41208 {
41209 PyThreadState* __tstate = wxPyBeginAllowThreads();
41210 (arg1)->SetFlexibleDirection(arg2);
41211
41212 wxPyEndAllowThreads(__tstate);
41213 if (PyErr_Occurred()) SWIG_fail;
41214 }
41215 Py_INCREF(Py_None); resultobj = Py_None;
41216 return resultobj;
41217 fail:
41218 return NULL;
41219 }
41220
41221
41222 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41223 PyObject *resultobj;
41224 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41225 int result;
41226 PyObject * obj0 = 0 ;
41227 char *kwnames[] = {
41228 (char *) "self", NULL
41229 };
41230
41231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41233 if (SWIG_arg_fail(1)) SWIG_fail;
41234 {
41235 PyThreadState* __tstate = wxPyBeginAllowThreads();
41236 result = (int)(arg1)->GetFlexibleDirection();
41237
41238 wxPyEndAllowThreads(__tstate);
41239 if (PyErr_Occurred()) SWIG_fail;
41240 }
41241 {
41242 resultobj = SWIG_From_int((int)(result));
41243 }
41244 return resultobj;
41245 fail:
41246 return NULL;
41247 }
41248
41249
41250 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41251 PyObject *resultobj;
41252 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41253 wxFlexSizerGrowMode arg2 ;
41254 PyObject * obj0 = 0 ;
41255 PyObject * obj1 = 0 ;
41256 char *kwnames[] = {
41257 (char *) "self",(char *) "mode", NULL
41258 };
41259
41260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41262 if (SWIG_arg_fail(1)) SWIG_fail;
41263 {
41264 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41265 if (SWIG_arg_fail(2)) SWIG_fail;
41266 }
41267 {
41268 PyThreadState* __tstate = wxPyBeginAllowThreads();
41269 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41270
41271 wxPyEndAllowThreads(__tstate);
41272 if (PyErr_Occurred()) SWIG_fail;
41273 }
41274 Py_INCREF(Py_None); resultobj = Py_None;
41275 return resultobj;
41276 fail:
41277 return NULL;
41278 }
41279
41280
41281 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41282 PyObject *resultobj;
41283 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41284 wxFlexSizerGrowMode result;
41285 PyObject * obj0 = 0 ;
41286 char *kwnames[] = {
41287 (char *) "self", NULL
41288 };
41289
41290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41292 if (SWIG_arg_fail(1)) SWIG_fail;
41293 {
41294 PyThreadState* __tstate = wxPyBeginAllowThreads();
41295 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41296
41297 wxPyEndAllowThreads(__tstate);
41298 if (PyErr_Occurred()) SWIG_fail;
41299 }
41300 resultobj = SWIG_From_int((result));
41301 return resultobj;
41302 fail:
41303 return NULL;
41304 }
41305
41306
41307 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41308 PyObject *resultobj;
41309 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41310 wxArrayInt *result;
41311 PyObject * obj0 = 0 ;
41312 char *kwnames[] = {
41313 (char *) "self", NULL
41314 };
41315
41316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41318 if (SWIG_arg_fail(1)) SWIG_fail;
41319 {
41320 PyThreadState* __tstate = wxPyBeginAllowThreads();
41321 {
41322 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41323 result = (wxArrayInt *) &_result_ref;
41324 }
41325
41326 wxPyEndAllowThreads(__tstate);
41327 if (PyErr_Occurred()) SWIG_fail;
41328 }
41329 {
41330 resultobj = PyList_New(0);
41331 size_t idx;
41332 for (idx = 0; idx < result->GetCount(); idx += 1) {
41333 PyObject* val = PyInt_FromLong( result->Item(idx) );
41334 PyList_Append(resultobj, val);
41335 Py_DECREF(val);
41336 }
41337 }
41338 return resultobj;
41339 fail:
41340 return NULL;
41341 }
41342
41343
41344 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41345 PyObject *resultobj;
41346 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41347 wxArrayInt *result;
41348 PyObject * obj0 = 0 ;
41349 char *kwnames[] = {
41350 (char *) "self", NULL
41351 };
41352
41353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41355 if (SWIG_arg_fail(1)) SWIG_fail;
41356 {
41357 PyThreadState* __tstate = wxPyBeginAllowThreads();
41358 {
41359 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41360 result = (wxArrayInt *) &_result_ref;
41361 }
41362
41363 wxPyEndAllowThreads(__tstate);
41364 if (PyErr_Occurred()) SWIG_fail;
41365 }
41366 {
41367 resultobj = PyList_New(0);
41368 size_t idx;
41369 for (idx = 0; idx < result->GetCount(); idx += 1) {
41370 PyObject* val = PyInt_FromLong( result->Item(idx) );
41371 PyList_Append(resultobj, val);
41372 Py_DECREF(val);
41373 }
41374 }
41375 return resultobj;
41376 fail:
41377 return NULL;
41378 }
41379
41380
41381 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41382 PyObject *obj;
41383 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41384 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41385 Py_INCREF(obj);
41386 return Py_BuildValue((char *)"");
41387 }
41388 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41389 PyObject *resultobj;
41390 wxStdDialogButtonSizer *result;
41391 char *kwnames[] = {
41392 NULL
41393 };
41394
41395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41396 {
41397 PyThreadState* __tstate = wxPyBeginAllowThreads();
41398 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41399
41400 wxPyEndAllowThreads(__tstate);
41401 if (PyErr_Occurred()) SWIG_fail;
41402 }
41403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41404 return resultobj;
41405 fail:
41406 return NULL;
41407 }
41408
41409
41410 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41411 PyObject *resultobj;
41412 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41413 wxButton *arg2 = (wxButton *) 0 ;
41414 PyObject * obj0 = 0 ;
41415 PyObject * obj1 = 0 ;
41416 char *kwnames[] = {
41417 (char *) "self",(char *) "button", NULL
41418 };
41419
41420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41422 if (SWIG_arg_fail(1)) SWIG_fail;
41423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41424 if (SWIG_arg_fail(2)) SWIG_fail;
41425 {
41426 PyThreadState* __tstate = wxPyBeginAllowThreads();
41427 (arg1)->AddButton(arg2);
41428
41429 wxPyEndAllowThreads(__tstate);
41430 if (PyErr_Occurred()) SWIG_fail;
41431 }
41432 Py_INCREF(Py_None); resultobj = Py_None;
41433 return resultobj;
41434 fail:
41435 return NULL;
41436 }
41437
41438
41439 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41440 PyObject *resultobj;
41441 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41442 PyObject * obj0 = 0 ;
41443 char *kwnames[] = {
41444 (char *) "self", NULL
41445 };
41446
41447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41449 if (SWIG_arg_fail(1)) SWIG_fail;
41450 {
41451 PyThreadState* __tstate = wxPyBeginAllowThreads();
41452 (arg1)->Realize();
41453
41454 wxPyEndAllowThreads(__tstate);
41455 if (PyErr_Occurred()) SWIG_fail;
41456 }
41457 Py_INCREF(Py_None); resultobj = Py_None;
41458 return resultobj;
41459 fail:
41460 return NULL;
41461 }
41462
41463
41464 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41465 PyObject *resultobj;
41466 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41467 wxButton *arg2 = (wxButton *) 0 ;
41468 PyObject * obj0 = 0 ;
41469 PyObject * obj1 = 0 ;
41470 char *kwnames[] = {
41471 (char *) "self",(char *) "button", NULL
41472 };
41473
41474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41476 if (SWIG_arg_fail(1)) SWIG_fail;
41477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41478 if (SWIG_arg_fail(2)) SWIG_fail;
41479 {
41480 PyThreadState* __tstate = wxPyBeginAllowThreads();
41481 (arg1)->SetAffirmativeButton(arg2);
41482
41483 wxPyEndAllowThreads(__tstate);
41484 if (PyErr_Occurred()) SWIG_fail;
41485 }
41486 Py_INCREF(Py_None); resultobj = Py_None;
41487 return resultobj;
41488 fail:
41489 return NULL;
41490 }
41491
41492
41493 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41494 PyObject *resultobj;
41495 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41496 wxButton *arg2 = (wxButton *) 0 ;
41497 PyObject * obj0 = 0 ;
41498 PyObject * obj1 = 0 ;
41499 char *kwnames[] = {
41500 (char *) "self",(char *) "button", NULL
41501 };
41502
41503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41505 if (SWIG_arg_fail(1)) SWIG_fail;
41506 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41507 if (SWIG_arg_fail(2)) SWIG_fail;
41508 {
41509 PyThreadState* __tstate = wxPyBeginAllowThreads();
41510 (arg1)->SetNegativeButton(arg2);
41511
41512 wxPyEndAllowThreads(__tstate);
41513 if (PyErr_Occurred()) SWIG_fail;
41514 }
41515 Py_INCREF(Py_None); resultobj = Py_None;
41516 return resultobj;
41517 fail:
41518 return NULL;
41519 }
41520
41521
41522 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41523 PyObject *resultobj;
41524 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41525 wxButton *arg2 = (wxButton *) 0 ;
41526 PyObject * obj0 = 0 ;
41527 PyObject * obj1 = 0 ;
41528 char *kwnames[] = {
41529 (char *) "self",(char *) "button", NULL
41530 };
41531
41532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41534 if (SWIG_arg_fail(1)) SWIG_fail;
41535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41536 if (SWIG_arg_fail(2)) SWIG_fail;
41537 {
41538 PyThreadState* __tstate = wxPyBeginAllowThreads();
41539 (arg1)->SetCancelButton(arg2);
41540
41541 wxPyEndAllowThreads(__tstate);
41542 if (PyErr_Occurred()) SWIG_fail;
41543 }
41544 Py_INCREF(Py_None); resultobj = Py_None;
41545 return resultobj;
41546 fail:
41547 return NULL;
41548 }
41549
41550
41551 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41552 PyObject *resultobj;
41553 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41554 wxButton *result;
41555 PyObject * obj0 = 0 ;
41556 char *kwnames[] = {
41557 (char *) "self", NULL
41558 };
41559
41560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41562 if (SWIG_arg_fail(1)) SWIG_fail;
41563 {
41564 PyThreadState* __tstate = wxPyBeginAllowThreads();
41565 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41566
41567 wxPyEndAllowThreads(__tstate);
41568 if (PyErr_Occurred()) SWIG_fail;
41569 }
41570 {
41571 resultobj = wxPyMake_wxObject(result, 0);
41572 }
41573 return resultobj;
41574 fail:
41575 return NULL;
41576 }
41577
41578
41579 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41580 PyObject *resultobj;
41581 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41582 wxButton *result;
41583 PyObject * obj0 = 0 ;
41584 char *kwnames[] = {
41585 (char *) "self", NULL
41586 };
41587
41588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41590 if (SWIG_arg_fail(1)) SWIG_fail;
41591 {
41592 PyThreadState* __tstate = wxPyBeginAllowThreads();
41593 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41594
41595 wxPyEndAllowThreads(__tstate);
41596 if (PyErr_Occurred()) SWIG_fail;
41597 }
41598 {
41599 resultobj = wxPyMake_wxObject(result, 0);
41600 }
41601 return resultobj;
41602 fail:
41603 return NULL;
41604 }
41605
41606
41607 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41608 PyObject *resultobj;
41609 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41610 wxButton *result;
41611 PyObject * obj0 = 0 ;
41612 char *kwnames[] = {
41613 (char *) "self", NULL
41614 };
41615
41616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41618 if (SWIG_arg_fail(1)) SWIG_fail;
41619 {
41620 PyThreadState* __tstate = wxPyBeginAllowThreads();
41621 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41622
41623 wxPyEndAllowThreads(__tstate);
41624 if (PyErr_Occurred()) SWIG_fail;
41625 }
41626 {
41627 resultobj = wxPyMake_wxObject(result, 0);
41628 }
41629 return resultobj;
41630 fail:
41631 return NULL;
41632 }
41633
41634
41635 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41636 PyObject *resultobj;
41637 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41638 wxButton *result;
41639 PyObject * obj0 = 0 ;
41640 char *kwnames[] = {
41641 (char *) "self", NULL
41642 };
41643
41644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41646 if (SWIG_arg_fail(1)) SWIG_fail;
41647 {
41648 PyThreadState* __tstate = wxPyBeginAllowThreads();
41649 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41650
41651 wxPyEndAllowThreads(__tstate);
41652 if (PyErr_Occurred()) SWIG_fail;
41653 }
41654 {
41655 resultobj = wxPyMake_wxObject(result, 0);
41656 }
41657 return resultobj;
41658 fail:
41659 return NULL;
41660 }
41661
41662
41663 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41664 PyObject *resultobj;
41665 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41666 wxButton *result;
41667 PyObject * obj0 = 0 ;
41668 char *kwnames[] = {
41669 (char *) "self", NULL
41670 };
41671
41672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41674 if (SWIG_arg_fail(1)) SWIG_fail;
41675 {
41676 PyThreadState* __tstate = wxPyBeginAllowThreads();
41677 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41678
41679 wxPyEndAllowThreads(__tstate);
41680 if (PyErr_Occurred()) SWIG_fail;
41681 }
41682 {
41683 resultobj = wxPyMake_wxObject(result, 0);
41684 }
41685 return resultobj;
41686 fail:
41687 return NULL;
41688 }
41689
41690
41691 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41692 PyObject *obj;
41693 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41694 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41695 Py_INCREF(obj);
41696 return Py_BuildValue((char *)"");
41697 }
41698 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41699 PyObject *resultobj;
41700 int arg1 = (int) 0 ;
41701 int arg2 = (int) 0 ;
41702 wxGBPosition *result;
41703 PyObject * obj0 = 0 ;
41704 PyObject * obj1 = 0 ;
41705 char *kwnames[] = {
41706 (char *) "row",(char *) "col", NULL
41707 };
41708
41709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41710 if (obj0) {
41711 {
41712 arg1 = (int)(SWIG_As_int(obj0));
41713 if (SWIG_arg_fail(1)) SWIG_fail;
41714 }
41715 }
41716 if (obj1) {
41717 {
41718 arg2 = (int)(SWIG_As_int(obj1));
41719 if (SWIG_arg_fail(2)) SWIG_fail;
41720 }
41721 }
41722 {
41723 PyThreadState* __tstate = wxPyBeginAllowThreads();
41724 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41725
41726 wxPyEndAllowThreads(__tstate);
41727 if (PyErr_Occurred()) SWIG_fail;
41728 }
41729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41730 return resultobj;
41731 fail:
41732 return NULL;
41733 }
41734
41735
41736 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41737 PyObject *resultobj;
41738 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41739 int result;
41740 PyObject * obj0 = 0 ;
41741 char *kwnames[] = {
41742 (char *) "self", NULL
41743 };
41744
41745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41747 if (SWIG_arg_fail(1)) SWIG_fail;
41748 {
41749 PyThreadState* __tstate = wxPyBeginAllowThreads();
41750 result = (int)((wxGBPosition const *)arg1)->GetRow();
41751
41752 wxPyEndAllowThreads(__tstate);
41753 if (PyErr_Occurred()) SWIG_fail;
41754 }
41755 {
41756 resultobj = SWIG_From_int((int)(result));
41757 }
41758 return resultobj;
41759 fail:
41760 return NULL;
41761 }
41762
41763
41764 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41765 PyObject *resultobj;
41766 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41767 int result;
41768 PyObject * obj0 = 0 ;
41769 char *kwnames[] = {
41770 (char *) "self", NULL
41771 };
41772
41773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41775 if (SWIG_arg_fail(1)) SWIG_fail;
41776 {
41777 PyThreadState* __tstate = wxPyBeginAllowThreads();
41778 result = (int)((wxGBPosition const *)arg1)->GetCol();
41779
41780 wxPyEndAllowThreads(__tstate);
41781 if (PyErr_Occurred()) SWIG_fail;
41782 }
41783 {
41784 resultobj = SWIG_From_int((int)(result));
41785 }
41786 return resultobj;
41787 fail:
41788 return NULL;
41789 }
41790
41791
41792 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41793 PyObject *resultobj;
41794 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41795 int arg2 ;
41796 PyObject * obj0 = 0 ;
41797 PyObject * obj1 = 0 ;
41798 char *kwnames[] = {
41799 (char *) "self",(char *) "row", NULL
41800 };
41801
41802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41804 if (SWIG_arg_fail(1)) SWIG_fail;
41805 {
41806 arg2 = (int)(SWIG_As_int(obj1));
41807 if (SWIG_arg_fail(2)) SWIG_fail;
41808 }
41809 {
41810 PyThreadState* __tstate = wxPyBeginAllowThreads();
41811 (arg1)->SetRow(arg2);
41812
41813 wxPyEndAllowThreads(__tstate);
41814 if (PyErr_Occurred()) SWIG_fail;
41815 }
41816 Py_INCREF(Py_None); resultobj = Py_None;
41817 return resultobj;
41818 fail:
41819 return NULL;
41820 }
41821
41822
41823 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41824 PyObject *resultobj;
41825 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41826 int arg2 ;
41827 PyObject * obj0 = 0 ;
41828 PyObject * obj1 = 0 ;
41829 char *kwnames[] = {
41830 (char *) "self",(char *) "col", NULL
41831 };
41832
41833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41835 if (SWIG_arg_fail(1)) SWIG_fail;
41836 {
41837 arg2 = (int)(SWIG_As_int(obj1));
41838 if (SWIG_arg_fail(2)) SWIG_fail;
41839 }
41840 {
41841 PyThreadState* __tstate = wxPyBeginAllowThreads();
41842 (arg1)->SetCol(arg2);
41843
41844 wxPyEndAllowThreads(__tstate);
41845 if (PyErr_Occurred()) SWIG_fail;
41846 }
41847 Py_INCREF(Py_None); resultobj = Py_None;
41848 return resultobj;
41849 fail:
41850 return NULL;
41851 }
41852
41853
41854 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41855 PyObject *resultobj;
41856 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41857 wxGBPosition *arg2 = 0 ;
41858 bool result;
41859 wxGBPosition temp2 ;
41860 PyObject * obj0 = 0 ;
41861 PyObject * obj1 = 0 ;
41862 char *kwnames[] = {
41863 (char *) "self",(char *) "other", NULL
41864 };
41865
41866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41868 if (SWIG_arg_fail(1)) SWIG_fail;
41869 {
41870 arg2 = &temp2;
41871 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41872 }
41873 {
41874 PyThreadState* __tstate = wxPyBeginAllowThreads();
41875 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41876
41877 wxPyEndAllowThreads(__tstate);
41878 if (PyErr_Occurred()) SWIG_fail;
41879 }
41880 {
41881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41882 }
41883 return resultobj;
41884 fail:
41885 return NULL;
41886 }
41887
41888
41889 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41890 PyObject *resultobj;
41891 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41892 wxGBPosition *arg2 = 0 ;
41893 bool result;
41894 wxGBPosition temp2 ;
41895 PyObject * obj0 = 0 ;
41896 PyObject * obj1 = 0 ;
41897 char *kwnames[] = {
41898 (char *) "self",(char *) "other", NULL
41899 };
41900
41901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41903 if (SWIG_arg_fail(1)) SWIG_fail;
41904 {
41905 arg2 = &temp2;
41906 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41907 }
41908 {
41909 PyThreadState* __tstate = wxPyBeginAllowThreads();
41910 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41911
41912 wxPyEndAllowThreads(__tstate);
41913 if (PyErr_Occurred()) SWIG_fail;
41914 }
41915 {
41916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41917 }
41918 return resultobj;
41919 fail:
41920 return NULL;
41921 }
41922
41923
41924 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41925 PyObject *resultobj;
41926 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41927 int arg2 = (int) 0 ;
41928 int arg3 = (int) 0 ;
41929 PyObject * obj0 = 0 ;
41930 PyObject * obj1 = 0 ;
41931 PyObject * obj2 = 0 ;
41932 char *kwnames[] = {
41933 (char *) "self",(char *) "row",(char *) "col", NULL
41934 };
41935
41936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41938 if (SWIG_arg_fail(1)) SWIG_fail;
41939 if (obj1) {
41940 {
41941 arg2 = (int)(SWIG_As_int(obj1));
41942 if (SWIG_arg_fail(2)) SWIG_fail;
41943 }
41944 }
41945 if (obj2) {
41946 {
41947 arg3 = (int)(SWIG_As_int(obj2));
41948 if (SWIG_arg_fail(3)) SWIG_fail;
41949 }
41950 }
41951 {
41952 PyThreadState* __tstate = wxPyBeginAllowThreads();
41953 wxGBPosition_Set(arg1,arg2,arg3);
41954
41955 wxPyEndAllowThreads(__tstate);
41956 if (PyErr_Occurred()) SWIG_fail;
41957 }
41958 Py_INCREF(Py_None); resultobj = Py_None;
41959 return resultobj;
41960 fail:
41961 return NULL;
41962 }
41963
41964
41965 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41966 PyObject *resultobj;
41967 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41968 PyObject *result;
41969 PyObject * obj0 = 0 ;
41970 char *kwnames[] = {
41971 (char *) "self", NULL
41972 };
41973
41974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41976 if (SWIG_arg_fail(1)) SWIG_fail;
41977 {
41978 PyThreadState* __tstate = wxPyBeginAllowThreads();
41979 result = (PyObject *)wxGBPosition_Get(arg1);
41980
41981 wxPyEndAllowThreads(__tstate);
41982 if (PyErr_Occurred()) SWIG_fail;
41983 }
41984 resultobj = result;
41985 return resultobj;
41986 fail:
41987 return NULL;
41988 }
41989
41990
41991 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41992 PyObject *obj;
41993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41994 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41995 Py_INCREF(obj);
41996 return Py_BuildValue((char *)"");
41997 }
41998 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41999 PyObject *resultobj;
42000 int arg1 = (int) 1 ;
42001 int arg2 = (int) 1 ;
42002 wxGBSpan *result;
42003 PyObject * obj0 = 0 ;
42004 PyObject * obj1 = 0 ;
42005 char *kwnames[] = {
42006 (char *) "rowspan",(char *) "colspan", NULL
42007 };
42008
42009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42010 if (obj0) {
42011 {
42012 arg1 = (int)(SWIG_As_int(obj0));
42013 if (SWIG_arg_fail(1)) SWIG_fail;
42014 }
42015 }
42016 if (obj1) {
42017 {
42018 arg2 = (int)(SWIG_As_int(obj1));
42019 if (SWIG_arg_fail(2)) SWIG_fail;
42020 }
42021 }
42022 {
42023 PyThreadState* __tstate = wxPyBeginAllowThreads();
42024 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42025
42026 wxPyEndAllowThreads(__tstate);
42027 if (PyErr_Occurred()) SWIG_fail;
42028 }
42029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42030 return resultobj;
42031 fail:
42032 return NULL;
42033 }
42034
42035
42036 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42037 PyObject *resultobj;
42038 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42039 int result;
42040 PyObject * obj0 = 0 ;
42041 char *kwnames[] = {
42042 (char *) "self", NULL
42043 };
42044
42045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42047 if (SWIG_arg_fail(1)) SWIG_fail;
42048 {
42049 PyThreadState* __tstate = wxPyBeginAllowThreads();
42050 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42051
42052 wxPyEndAllowThreads(__tstate);
42053 if (PyErr_Occurred()) SWIG_fail;
42054 }
42055 {
42056 resultobj = SWIG_From_int((int)(result));
42057 }
42058 return resultobj;
42059 fail:
42060 return NULL;
42061 }
42062
42063
42064 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42065 PyObject *resultobj;
42066 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42067 int result;
42068 PyObject * obj0 = 0 ;
42069 char *kwnames[] = {
42070 (char *) "self", NULL
42071 };
42072
42073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42075 if (SWIG_arg_fail(1)) SWIG_fail;
42076 {
42077 PyThreadState* __tstate = wxPyBeginAllowThreads();
42078 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42079
42080 wxPyEndAllowThreads(__tstate);
42081 if (PyErr_Occurred()) SWIG_fail;
42082 }
42083 {
42084 resultobj = SWIG_From_int((int)(result));
42085 }
42086 return resultobj;
42087 fail:
42088 return NULL;
42089 }
42090
42091
42092 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42093 PyObject *resultobj;
42094 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42095 int arg2 ;
42096 PyObject * obj0 = 0 ;
42097 PyObject * obj1 = 0 ;
42098 char *kwnames[] = {
42099 (char *) "self",(char *) "rowspan", NULL
42100 };
42101
42102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42104 if (SWIG_arg_fail(1)) SWIG_fail;
42105 {
42106 arg2 = (int)(SWIG_As_int(obj1));
42107 if (SWIG_arg_fail(2)) SWIG_fail;
42108 }
42109 {
42110 PyThreadState* __tstate = wxPyBeginAllowThreads();
42111 (arg1)->SetRowspan(arg2);
42112
42113 wxPyEndAllowThreads(__tstate);
42114 if (PyErr_Occurred()) SWIG_fail;
42115 }
42116 Py_INCREF(Py_None); resultobj = Py_None;
42117 return resultobj;
42118 fail:
42119 return NULL;
42120 }
42121
42122
42123 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42124 PyObject *resultobj;
42125 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42126 int arg2 ;
42127 PyObject * obj0 = 0 ;
42128 PyObject * obj1 = 0 ;
42129 char *kwnames[] = {
42130 (char *) "self",(char *) "colspan", NULL
42131 };
42132
42133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42135 if (SWIG_arg_fail(1)) SWIG_fail;
42136 {
42137 arg2 = (int)(SWIG_As_int(obj1));
42138 if (SWIG_arg_fail(2)) SWIG_fail;
42139 }
42140 {
42141 PyThreadState* __tstate = wxPyBeginAllowThreads();
42142 (arg1)->SetColspan(arg2);
42143
42144 wxPyEndAllowThreads(__tstate);
42145 if (PyErr_Occurred()) SWIG_fail;
42146 }
42147 Py_INCREF(Py_None); resultobj = Py_None;
42148 return resultobj;
42149 fail:
42150 return NULL;
42151 }
42152
42153
42154 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42155 PyObject *resultobj;
42156 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42157 wxGBSpan *arg2 = 0 ;
42158 bool result;
42159 wxGBSpan temp2 ;
42160 PyObject * obj0 = 0 ;
42161 PyObject * obj1 = 0 ;
42162 char *kwnames[] = {
42163 (char *) "self",(char *) "other", NULL
42164 };
42165
42166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42168 if (SWIG_arg_fail(1)) SWIG_fail;
42169 {
42170 arg2 = &temp2;
42171 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42172 }
42173 {
42174 PyThreadState* __tstate = wxPyBeginAllowThreads();
42175 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42176
42177 wxPyEndAllowThreads(__tstate);
42178 if (PyErr_Occurred()) SWIG_fail;
42179 }
42180 {
42181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42182 }
42183 return resultobj;
42184 fail:
42185 return NULL;
42186 }
42187
42188
42189 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42190 PyObject *resultobj;
42191 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42192 wxGBSpan *arg2 = 0 ;
42193 bool result;
42194 wxGBSpan temp2 ;
42195 PyObject * obj0 = 0 ;
42196 PyObject * obj1 = 0 ;
42197 char *kwnames[] = {
42198 (char *) "self",(char *) "other", NULL
42199 };
42200
42201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42203 if (SWIG_arg_fail(1)) SWIG_fail;
42204 {
42205 arg2 = &temp2;
42206 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42207 }
42208 {
42209 PyThreadState* __tstate = wxPyBeginAllowThreads();
42210 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42211
42212 wxPyEndAllowThreads(__tstate);
42213 if (PyErr_Occurred()) SWIG_fail;
42214 }
42215 {
42216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42217 }
42218 return resultobj;
42219 fail:
42220 return NULL;
42221 }
42222
42223
42224 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42225 PyObject *resultobj;
42226 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42227 int arg2 = (int) 1 ;
42228 int arg3 = (int) 1 ;
42229 PyObject * obj0 = 0 ;
42230 PyObject * obj1 = 0 ;
42231 PyObject * obj2 = 0 ;
42232 char *kwnames[] = {
42233 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42234 };
42235
42236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42238 if (SWIG_arg_fail(1)) SWIG_fail;
42239 if (obj1) {
42240 {
42241 arg2 = (int)(SWIG_As_int(obj1));
42242 if (SWIG_arg_fail(2)) SWIG_fail;
42243 }
42244 }
42245 if (obj2) {
42246 {
42247 arg3 = (int)(SWIG_As_int(obj2));
42248 if (SWIG_arg_fail(3)) SWIG_fail;
42249 }
42250 }
42251 {
42252 PyThreadState* __tstate = wxPyBeginAllowThreads();
42253 wxGBSpan_Set(arg1,arg2,arg3);
42254
42255 wxPyEndAllowThreads(__tstate);
42256 if (PyErr_Occurred()) SWIG_fail;
42257 }
42258 Py_INCREF(Py_None); resultobj = Py_None;
42259 return resultobj;
42260 fail:
42261 return NULL;
42262 }
42263
42264
42265 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42266 PyObject *resultobj;
42267 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42268 PyObject *result;
42269 PyObject * obj0 = 0 ;
42270 char *kwnames[] = {
42271 (char *) "self", NULL
42272 };
42273
42274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42276 if (SWIG_arg_fail(1)) SWIG_fail;
42277 {
42278 PyThreadState* __tstate = wxPyBeginAllowThreads();
42279 result = (PyObject *)wxGBSpan_Get(arg1);
42280
42281 wxPyEndAllowThreads(__tstate);
42282 if (PyErr_Occurred()) SWIG_fail;
42283 }
42284 resultobj = result;
42285 return resultobj;
42286 fail:
42287 return NULL;
42288 }
42289
42290
42291 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42292 PyObject *obj;
42293 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42294 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42295 Py_INCREF(obj);
42296 return Py_BuildValue((char *)"");
42297 }
42298 static int _wrap_DefaultSpan_set(PyObject *) {
42299 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42300 return 1;
42301 }
42302
42303
42304 static PyObject *_wrap_DefaultSpan_get(void) {
42305 PyObject *pyobj;
42306
42307 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42308 return pyobj;
42309 }
42310
42311
42312 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42313 PyObject *resultobj;
42314 wxGBSizerItem *result;
42315 char *kwnames[] = {
42316 NULL
42317 };
42318
42319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42320 {
42321 PyThreadState* __tstate = wxPyBeginAllowThreads();
42322 result = (wxGBSizerItem *)new wxGBSizerItem();
42323
42324 wxPyEndAllowThreads(__tstate);
42325 if (PyErr_Occurred()) SWIG_fail;
42326 }
42327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42328 return resultobj;
42329 fail:
42330 return NULL;
42331 }
42332
42333
42334 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42335 PyObject *resultobj;
42336 wxWindow *arg1 = (wxWindow *) 0 ;
42337 wxGBPosition *arg2 = 0 ;
42338 wxGBSpan *arg3 = 0 ;
42339 int arg4 ;
42340 int arg5 ;
42341 PyObject *arg6 = (PyObject *) NULL ;
42342 wxGBSizerItem *result;
42343 wxGBPosition temp2 ;
42344 wxGBSpan temp3 ;
42345 PyObject * obj0 = 0 ;
42346 PyObject * obj1 = 0 ;
42347 PyObject * obj2 = 0 ;
42348 PyObject * obj3 = 0 ;
42349 PyObject * obj4 = 0 ;
42350 PyObject * obj5 = 0 ;
42351 char *kwnames[] = {
42352 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42353 };
42354
42355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42357 if (SWIG_arg_fail(1)) SWIG_fail;
42358 {
42359 arg2 = &temp2;
42360 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42361 }
42362 {
42363 arg3 = &temp3;
42364 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42365 }
42366 {
42367 arg4 = (int)(SWIG_As_int(obj3));
42368 if (SWIG_arg_fail(4)) SWIG_fail;
42369 }
42370 {
42371 arg5 = (int)(SWIG_As_int(obj4));
42372 if (SWIG_arg_fail(5)) SWIG_fail;
42373 }
42374 if (obj5) {
42375 arg6 = obj5;
42376 }
42377 {
42378 PyThreadState* __tstate = wxPyBeginAllowThreads();
42379 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42380
42381 wxPyEndAllowThreads(__tstate);
42382 if (PyErr_Occurred()) SWIG_fail;
42383 }
42384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42392 PyObject *resultobj;
42393 wxSizer *arg1 = (wxSizer *) 0 ;
42394 wxGBPosition *arg2 = 0 ;
42395 wxGBSpan *arg3 = 0 ;
42396 int arg4 ;
42397 int arg5 ;
42398 PyObject *arg6 = (PyObject *) NULL ;
42399 wxGBSizerItem *result;
42400 wxGBPosition temp2 ;
42401 wxGBSpan temp3 ;
42402 PyObject * obj0 = 0 ;
42403 PyObject * obj1 = 0 ;
42404 PyObject * obj2 = 0 ;
42405 PyObject * obj3 = 0 ;
42406 PyObject * obj4 = 0 ;
42407 PyObject * obj5 = 0 ;
42408 char *kwnames[] = {
42409 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42410 };
42411
42412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42414 if (SWIG_arg_fail(1)) SWIG_fail;
42415 {
42416 arg2 = &temp2;
42417 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42418 }
42419 {
42420 arg3 = &temp3;
42421 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42422 }
42423 {
42424 arg4 = (int)(SWIG_As_int(obj3));
42425 if (SWIG_arg_fail(4)) SWIG_fail;
42426 }
42427 {
42428 arg5 = (int)(SWIG_As_int(obj4));
42429 if (SWIG_arg_fail(5)) SWIG_fail;
42430 }
42431 if (obj5) {
42432 arg6 = obj5;
42433 }
42434 {
42435 PyThreadState* __tstate = wxPyBeginAllowThreads();
42436 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42437
42438 wxPyEndAllowThreads(__tstate);
42439 if (PyErr_Occurred()) SWIG_fail;
42440 }
42441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42442 return resultobj;
42443 fail:
42444 return NULL;
42445 }
42446
42447
42448 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42449 PyObject *resultobj;
42450 int arg1 ;
42451 int arg2 ;
42452 wxGBPosition *arg3 = 0 ;
42453 wxGBSpan *arg4 = 0 ;
42454 int arg5 ;
42455 int arg6 ;
42456 PyObject *arg7 = (PyObject *) NULL ;
42457 wxGBSizerItem *result;
42458 wxGBPosition temp3 ;
42459 wxGBSpan temp4 ;
42460 PyObject * obj0 = 0 ;
42461 PyObject * obj1 = 0 ;
42462 PyObject * obj2 = 0 ;
42463 PyObject * obj3 = 0 ;
42464 PyObject * obj4 = 0 ;
42465 PyObject * obj5 = 0 ;
42466 PyObject * obj6 = 0 ;
42467 char *kwnames[] = {
42468 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42469 };
42470
42471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42472 {
42473 arg1 = (int)(SWIG_As_int(obj0));
42474 if (SWIG_arg_fail(1)) SWIG_fail;
42475 }
42476 {
42477 arg2 = (int)(SWIG_As_int(obj1));
42478 if (SWIG_arg_fail(2)) SWIG_fail;
42479 }
42480 {
42481 arg3 = &temp3;
42482 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42483 }
42484 {
42485 arg4 = &temp4;
42486 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42487 }
42488 {
42489 arg5 = (int)(SWIG_As_int(obj4));
42490 if (SWIG_arg_fail(5)) SWIG_fail;
42491 }
42492 {
42493 arg6 = (int)(SWIG_As_int(obj5));
42494 if (SWIG_arg_fail(6)) SWIG_fail;
42495 }
42496 if (obj6) {
42497 arg7 = obj6;
42498 }
42499 {
42500 PyThreadState* __tstate = wxPyBeginAllowThreads();
42501 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42502
42503 wxPyEndAllowThreads(__tstate);
42504 if (PyErr_Occurred()) SWIG_fail;
42505 }
42506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42507 return resultobj;
42508 fail:
42509 return NULL;
42510 }
42511
42512
42513 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42514 PyObject *resultobj;
42515 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42516 wxGBPosition result;
42517 PyObject * obj0 = 0 ;
42518 char *kwnames[] = {
42519 (char *) "self", NULL
42520 };
42521
42522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42524 if (SWIG_arg_fail(1)) SWIG_fail;
42525 {
42526 PyThreadState* __tstate = wxPyBeginAllowThreads();
42527 result = ((wxGBSizerItem const *)arg1)->GetPos();
42528
42529 wxPyEndAllowThreads(__tstate);
42530 if (PyErr_Occurred()) SWIG_fail;
42531 }
42532 {
42533 wxGBPosition * resultptr;
42534 resultptr = new wxGBPosition((wxGBPosition &)(result));
42535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42536 }
42537 return resultobj;
42538 fail:
42539 return NULL;
42540 }
42541
42542
42543 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42544 PyObject *resultobj;
42545 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42546 wxGBSpan result;
42547 PyObject * obj0 = 0 ;
42548 char *kwnames[] = {
42549 (char *) "self", NULL
42550 };
42551
42552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42554 if (SWIG_arg_fail(1)) SWIG_fail;
42555 {
42556 PyThreadState* __tstate = wxPyBeginAllowThreads();
42557 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42558
42559 wxPyEndAllowThreads(__tstate);
42560 if (PyErr_Occurred()) SWIG_fail;
42561 }
42562 {
42563 wxGBSpan * resultptr;
42564 resultptr = new wxGBSpan((wxGBSpan &)(result));
42565 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42566 }
42567 return resultobj;
42568 fail:
42569 return NULL;
42570 }
42571
42572
42573 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42574 PyObject *resultobj;
42575 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42576 wxGBPosition *arg2 = 0 ;
42577 bool result;
42578 wxGBPosition temp2 ;
42579 PyObject * obj0 = 0 ;
42580 PyObject * obj1 = 0 ;
42581 char *kwnames[] = {
42582 (char *) "self",(char *) "pos", NULL
42583 };
42584
42585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42587 if (SWIG_arg_fail(1)) SWIG_fail;
42588 {
42589 arg2 = &temp2;
42590 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42591 }
42592 {
42593 PyThreadState* __tstate = wxPyBeginAllowThreads();
42594 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42595
42596 wxPyEndAllowThreads(__tstate);
42597 if (PyErr_Occurred()) SWIG_fail;
42598 }
42599 {
42600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42601 }
42602 return resultobj;
42603 fail:
42604 return NULL;
42605 }
42606
42607
42608 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42609 PyObject *resultobj;
42610 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42611 wxGBSpan *arg2 = 0 ;
42612 bool result;
42613 wxGBSpan temp2 ;
42614 PyObject * obj0 = 0 ;
42615 PyObject * obj1 = 0 ;
42616 char *kwnames[] = {
42617 (char *) "self",(char *) "span", NULL
42618 };
42619
42620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42622 if (SWIG_arg_fail(1)) SWIG_fail;
42623 {
42624 arg2 = &temp2;
42625 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42626 }
42627 {
42628 PyThreadState* __tstate = wxPyBeginAllowThreads();
42629 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42630
42631 wxPyEndAllowThreads(__tstate);
42632 if (PyErr_Occurred()) SWIG_fail;
42633 }
42634 {
42635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42636 }
42637 return resultobj;
42638 fail:
42639 return NULL;
42640 }
42641
42642
42643 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42644 PyObject *resultobj;
42645 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42646 wxGBSizerItem *arg2 = 0 ;
42647 bool result;
42648 PyObject * obj0 = 0 ;
42649 PyObject * obj1 = 0 ;
42650 char *kwnames[] = {
42651 (char *) "self",(char *) "other", NULL
42652 };
42653
42654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42656 if (SWIG_arg_fail(1)) SWIG_fail;
42657 {
42658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42659 if (SWIG_arg_fail(2)) SWIG_fail;
42660 if (arg2 == NULL) {
42661 SWIG_null_ref("wxGBSizerItem");
42662 }
42663 if (SWIG_arg_fail(2)) SWIG_fail;
42664 }
42665 {
42666 PyThreadState* __tstate = wxPyBeginAllowThreads();
42667 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42668
42669 wxPyEndAllowThreads(__tstate);
42670 if (PyErr_Occurred()) SWIG_fail;
42671 }
42672 {
42673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42674 }
42675 return resultobj;
42676 fail:
42677 return NULL;
42678 }
42679
42680
42681 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42682 PyObject *resultobj;
42683 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42684 wxGBPosition *arg2 = 0 ;
42685 wxGBSpan *arg3 = 0 ;
42686 bool result;
42687 wxGBPosition temp2 ;
42688 wxGBSpan temp3 ;
42689 PyObject * obj0 = 0 ;
42690 PyObject * obj1 = 0 ;
42691 PyObject * obj2 = 0 ;
42692 char *kwnames[] = {
42693 (char *) "self",(char *) "pos",(char *) "span", NULL
42694 };
42695
42696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42698 if (SWIG_arg_fail(1)) SWIG_fail;
42699 {
42700 arg2 = &temp2;
42701 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42702 }
42703 {
42704 arg3 = &temp3;
42705 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42706 }
42707 {
42708 PyThreadState* __tstate = wxPyBeginAllowThreads();
42709 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42710
42711 wxPyEndAllowThreads(__tstate);
42712 if (PyErr_Occurred()) SWIG_fail;
42713 }
42714 {
42715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42716 }
42717 return resultobj;
42718 fail:
42719 return NULL;
42720 }
42721
42722
42723 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42724 PyObject *resultobj;
42725 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42726 wxGBPosition result;
42727 PyObject * obj0 = 0 ;
42728 char *kwnames[] = {
42729 (char *) "self", NULL
42730 };
42731
42732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42734 if (SWIG_arg_fail(1)) SWIG_fail;
42735 {
42736 PyThreadState* __tstate = wxPyBeginAllowThreads();
42737 result = wxGBSizerItem_GetEndPos(arg1);
42738
42739 wxPyEndAllowThreads(__tstate);
42740 if (PyErr_Occurred()) SWIG_fail;
42741 }
42742 {
42743 wxGBPosition * resultptr;
42744 resultptr = new wxGBPosition((wxGBPosition &)(result));
42745 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42746 }
42747 return resultobj;
42748 fail:
42749 return NULL;
42750 }
42751
42752
42753 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42754 PyObject *resultobj;
42755 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42756 wxGridBagSizer *result;
42757 PyObject * obj0 = 0 ;
42758 char *kwnames[] = {
42759 (char *) "self", NULL
42760 };
42761
42762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42764 if (SWIG_arg_fail(1)) SWIG_fail;
42765 {
42766 PyThreadState* __tstate = wxPyBeginAllowThreads();
42767 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42768
42769 wxPyEndAllowThreads(__tstate);
42770 if (PyErr_Occurred()) SWIG_fail;
42771 }
42772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42773 return resultobj;
42774 fail:
42775 return NULL;
42776 }
42777
42778
42779 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42780 PyObject *resultobj;
42781 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42782 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42783 PyObject * obj0 = 0 ;
42784 PyObject * obj1 = 0 ;
42785 char *kwnames[] = {
42786 (char *) "self",(char *) "sizer", NULL
42787 };
42788
42789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42791 if (SWIG_arg_fail(1)) SWIG_fail;
42792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42793 if (SWIG_arg_fail(2)) SWIG_fail;
42794 {
42795 PyThreadState* __tstate = wxPyBeginAllowThreads();
42796 (arg1)->SetGBSizer(arg2);
42797
42798 wxPyEndAllowThreads(__tstate);
42799 if (PyErr_Occurred()) SWIG_fail;
42800 }
42801 Py_INCREF(Py_None); resultobj = Py_None;
42802 return resultobj;
42803 fail:
42804 return NULL;
42805 }
42806
42807
42808 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42809 PyObject *obj;
42810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42811 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42812 Py_INCREF(obj);
42813 return Py_BuildValue((char *)"");
42814 }
42815 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42816 PyObject *resultobj;
42817 int arg1 = (int) 0 ;
42818 int arg2 = (int) 0 ;
42819 wxGridBagSizer *result;
42820 PyObject * obj0 = 0 ;
42821 PyObject * obj1 = 0 ;
42822 char *kwnames[] = {
42823 (char *) "vgap",(char *) "hgap", NULL
42824 };
42825
42826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42827 if (obj0) {
42828 {
42829 arg1 = (int)(SWIG_As_int(obj0));
42830 if (SWIG_arg_fail(1)) SWIG_fail;
42831 }
42832 }
42833 if (obj1) {
42834 {
42835 arg2 = (int)(SWIG_As_int(obj1));
42836 if (SWIG_arg_fail(2)) SWIG_fail;
42837 }
42838 }
42839 {
42840 PyThreadState* __tstate = wxPyBeginAllowThreads();
42841 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42842
42843 wxPyEndAllowThreads(__tstate);
42844 if (PyErr_Occurred()) SWIG_fail;
42845 }
42846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42847 return resultobj;
42848 fail:
42849 return NULL;
42850 }
42851
42852
42853 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42854 PyObject *resultobj;
42855 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42856 PyObject *arg2 = (PyObject *) 0 ;
42857 wxGBPosition *arg3 = 0 ;
42858 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42859 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42860 int arg5 = (int) 0 ;
42861 int arg6 = (int) 0 ;
42862 PyObject *arg7 = (PyObject *) NULL ;
42863 wxGBSizerItem *result;
42864 wxGBPosition temp3 ;
42865 wxGBSpan temp4 ;
42866 PyObject * obj0 = 0 ;
42867 PyObject * obj1 = 0 ;
42868 PyObject * obj2 = 0 ;
42869 PyObject * obj3 = 0 ;
42870 PyObject * obj4 = 0 ;
42871 PyObject * obj5 = 0 ;
42872 PyObject * obj6 = 0 ;
42873 char *kwnames[] = {
42874 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42875 };
42876
42877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42879 if (SWIG_arg_fail(1)) SWIG_fail;
42880 arg2 = obj1;
42881 {
42882 arg3 = &temp3;
42883 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42884 }
42885 if (obj3) {
42886 {
42887 arg4 = &temp4;
42888 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42889 }
42890 }
42891 if (obj4) {
42892 {
42893 arg5 = (int)(SWIG_As_int(obj4));
42894 if (SWIG_arg_fail(5)) SWIG_fail;
42895 }
42896 }
42897 if (obj5) {
42898 {
42899 arg6 = (int)(SWIG_As_int(obj5));
42900 if (SWIG_arg_fail(6)) SWIG_fail;
42901 }
42902 }
42903 if (obj6) {
42904 arg7 = obj6;
42905 }
42906 {
42907 PyThreadState* __tstate = wxPyBeginAllowThreads();
42908 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42909
42910 wxPyEndAllowThreads(__tstate);
42911 if (PyErr_Occurred()) SWIG_fail;
42912 }
42913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42914 return resultobj;
42915 fail:
42916 return NULL;
42917 }
42918
42919
42920 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42921 PyObject *resultobj;
42922 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42923 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42924 wxGBSizerItem *result;
42925 PyObject * obj0 = 0 ;
42926 PyObject * obj1 = 0 ;
42927 char *kwnames[] = {
42928 (char *) "self",(char *) "item", NULL
42929 };
42930
42931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42933 if (SWIG_arg_fail(1)) SWIG_fail;
42934 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42935 if (SWIG_arg_fail(2)) SWIG_fail;
42936 {
42937 PyThreadState* __tstate = wxPyBeginAllowThreads();
42938 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42939
42940 wxPyEndAllowThreads(__tstate);
42941 if (PyErr_Occurred()) SWIG_fail;
42942 }
42943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42944 return resultobj;
42945 fail:
42946 return NULL;
42947 }
42948
42949
42950 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42951 PyObject *resultobj;
42952 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42953 int arg2 ;
42954 int arg3 ;
42955 wxSize result;
42956 PyObject * obj0 = 0 ;
42957 PyObject * obj1 = 0 ;
42958 PyObject * obj2 = 0 ;
42959 char *kwnames[] = {
42960 (char *) "self",(char *) "row",(char *) "col", NULL
42961 };
42962
42963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42965 if (SWIG_arg_fail(1)) SWIG_fail;
42966 {
42967 arg2 = (int)(SWIG_As_int(obj1));
42968 if (SWIG_arg_fail(2)) SWIG_fail;
42969 }
42970 {
42971 arg3 = (int)(SWIG_As_int(obj2));
42972 if (SWIG_arg_fail(3)) SWIG_fail;
42973 }
42974 {
42975 PyThreadState* __tstate = wxPyBeginAllowThreads();
42976 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42977
42978 wxPyEndAllowThreads(__tstate);
42979 if (PyErr_Occurred()) SWIG_fail;
42980 }
42981 {
42982 wxSize * resultptr;
42983 resultptr = new wxSize((wxSize &)(result));
42984 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42985 }
42986 return resultobj;
42987 fail:
42988 return NULL;
42989 }
42990
42991
42992 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42993 PyObject *resultobj;
42994 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42995 wxSize result;
42996 PyObject * obj0 = 0 ;
42997 char *kwnames[] = {
42998 (char *) "self", NULL
42999 };
43000
43001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43003 if (SWIG_arg_fail(1)) SWIG_fail;
43004 {
43005 PyThreadState* __tstate = wxPyBeginAllowThreads();
43006 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43007
43008 wxPyEndAllowThreads(__tstate);
43009 if (PyErr_Occurred()) SWIG_fail;
43010 }
43011 {
43012 wxSize * resultptr;
43013 resultptr = new wxSize((wxSize &)(result));
43014 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43015 }
43016 return resultobj;
43017 fail:
43018 return NULL;
43019 }
43020
43021
43022 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43023 PyObject *resultobj;
43024 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43025 wxSize *arg2 = 0 ;
43026 wxSize temp2 ;
43027 PyObject * obj0 = 0 ;
43028 PyObject * obj1 = 0 ;
43029 char *kwnames[] = {
43030 (char *) "self",(char *) "sz", NULL
43031 };
43032
43033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43035 if (SWIG_arg_fail(1)) SWIG_fail;
43036 {
43037 arg2 = &temp2;
43038 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43039 }
43040 {
43041 PyThreadState* __tstate = wxPyBeginAllowThreads();
43042 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43043
43044 wxPyEndAllowThreads(__tstate);
43045 if (PyErr_Occurred()) SWIG_fail;
43046 }
43047 Py_INCREF(Py_None); resultobj = Py_None;
43048 return resultobj;
43049 fail:
43050 return NULL;
43051 }
43052
43053
43054 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43055 PyObject *resultobj;
43056 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43057 wxWindow *arg2 = (wxWindow *) 0 ;
43058 wxGBPosition result;
43059 PyObject * obj0 = 0 ;
43060 PyObject * obj1 = 0 ;
43061
43062 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43064 if (SWIG_arg_fail(1)) SWIG_fail;
43065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43066 if (SWIG_arg_fail(2)) SWIG_fail;
43067 {
43068 PyThreadState* __tstate = wxPyBeginAllowThreads();
43069 result = (arg1)->GetItemPosition(arg2);
43070
43071 wxPyEndAllowThreads(__tstate);
43072 if (PyErr_Occurred()) SWIG_fail;
43073 }
43074 {
43075 wxGBPosition * resultptr;
43076 resultptr = new wxGBPosition((wxGBPosition &)(result));
43077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43078 }
43079 return resultobj;
43080 fail:
43081 return NULL;
43082 }
43083
43084
43085 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43086 PyObject *resultobj;
43087 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43088 wxSizer *arg2 = (wxSizer *) 0 ;
43089 wxGBPosition result;
43090 PyObject * obj0 = 0 ;
43091 PyObject * obj1 = 0 ;
43092
43093 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43095 if (SWIG_arg_fail(1)) SWIG_fail;
43096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43097 if (SWIG_arg_fail(2)) SWIG_fail;
43098 {
43099 PyThreadState* __tstate = wxPyBeginAllowThreads();
43100 result = (arg1)->GetItemPosition(arg2);
43101
43102 wxPyEndAllowThreads(__tstate);
43103 if (PyErr_Occurred()) SWIG_fail;
43104 }
43105 {
43106 wxGBPosition * resultptr;
43107 resultptr = new wxGBPosition((wxGBPosition &)(result));
43108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43109 }
43110 return resultobj;
43111 fail:
43112 return NULL;
43113 }
43114
43115
43116 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43117 PyObject *resultobj;
43118 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43119 size_t arg2 ;
43120 wxGBPosition result;
43121 PyObject * obj0 = 0 ;
43122 PyObject * obj1 = 0 ;
43123
43124 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43126 if (SWIG_arg_fail(1)) SWIG_fail;
43127 {
43128 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43129 if (SWIG_arg_fail(2)) SWIG_fail;
43130 }
43131 {
43132 PyThreadState* __tstate = wxPyBeginAllowThreads();
43133 result = (arg1)->GetItemPosition(arg2);
43134
43135 wxPyEndAllowThreads(__tstate);
43136 if (PyErr_Occurred()) SWIG_fail;
43137 }
43138 {
43139 wxGBPosition * resultptr;
43140 resultptr = new wxGBPosition((wxGBPosition &)(result));
43141 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43142 }
43143 return resultobj;
43144 fail:
43145 return NULL;
43146 }
43147
43148
43149 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43150 int argc;
43151 PyObject *argv[3];
43152 int ii;
43153
43154 argc = PyObject_Length(args);
43155 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43156 argv[ii] = PyTuple_GetItem(args,ii);
43157 }
43158 if (argc == 2) {
43159 int _v;
43160 {
43161 void *ptr;
43162 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43163 _v = 0;
43164 PyErr_Clear();
43165 } else {
43166 _v = 1;
43167 }
43168 }
43169 if (_v) {
43170 {
43171 void *ptr;
43172 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43173 _v = 0;
43174 PyErr_Clear();
43175 } else {
43176 _v = 1;
43177 }
43178 }
43179 if (_v) {
43180 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43181 }
43182 }
43183 }
43184 if (argc == 2) {
43185 int _v;
43186 {
43187 void *ptr;
43188 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43189 _v = 0;
43190 PyErr_Clear();
43191 } else {
43192 _v = 1;
43193 }
43194 }
43195 if (_v) {
43196 {
43197 void *ptr;
43198 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43199 _v = 0;
43200 PyErr_Clear();
43201 } else {
43202 _v = 1;
43203 }
43204 }
43205 if (_v) {
43206 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43207 }
43208 }
43209 }
43210 if (argc == 2) {
43211 int _v;
43212 {
43213 void *ptr;
43214 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43215 _v = 0;
43216 PyErr_Clear();
43217 } else {
43218 _v = 1;
43219 }
43220 }
43221 if (_v) {
43222 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43223 if (_v) {
43224 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43225 }
43226 }
43227 }
43228
43229 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43230 return NULL;
43231 }
43232
43233
43234 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43235 PyObject *resultobj;
43236 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43237 wxWindow *arg2 = (wxWindow *) 0 ;
43238 wxGBPosition *arg3 = 0 ;
43239 bool result;
43240 wxGBPosition temp3 ;
43241 PyObject * obj0 = 0 ;
43242 PyObject * obj1 = 0 ;
43243 PyObject * obj2 = 0 ;
43244
43245 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43247 if (SWIG_arg_fail(1)) SWIG_fail;
43248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43249 if (SWIG_arg_fail(2)) SWIG_fail;
43250 {
43251 arg3 = &temp3;
43252 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43253 }
43254 {
43255 PyThreadState* __tstate = wxPyBeginAllowThreads();
43256 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43257
43258 wxPyEndAllowThreads(__tstate);
43259 if (PyErr_Occurred()) SWIG_fail;
43260 }
43261 {
43262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43263 }
43264 return resultobj;
43265 fail:
43266 return NULL;
43267 }
43268
43269
43270 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43271 PyObject *resultobj;
43272 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43273 wxSizer *arg2 = (wxSizer *) 0 ;
43274 wxGBPosition *arg3 = 0 ;
43275 bool result;
43276 wxGBPosition temp3 ;
43277 PyObject * obj0 = 0 ;
43278 PyObject * obj1 = 0 ;
43279 PyObject * obj2 = 0 ;
43280
43281 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43283 if (SWIG_arg_fail(1)) SWIG_fail;
43284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43285 if (SWIG_arg_fail(2)) SWIG_fail;
43286 {
43287 arg3 = &temp3;
43288 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43289 }
43290 {
43291 PyThreadState* __tstate = wxPyBeginAllowThreads();
43292 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43293
43294 wxPyEndAllowThreads(__tstate);
43295 if (PyErr_Occurred()) SWIG_fail;
43296 }
43297 {
43298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43299 }
43300 return resultobj;
43301 fail:
43302 return NULL;
43303 }
43304
43305
43306 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43307 PyObject *resultobj;
43308 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43309 size_t arg2 ;
43310 wxGBPosition *arg3 = 0 ;
43311 bool result;
43312 wxGBPosition temp3 ;
43313 PyObject * obj0 = 0 ;
43314 PyObject * obj1 = 0 ;
43315 PyObject * obj2 = 0 ;
43316
43317 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43319 if (SWIG_arg_fail(1)) SWIG_fail;
43320 {
43321 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43322 if (SWIG_arg_fail(2)) SWIG_fail;
43323 }
43324 {
43325 arg3 = &temp3;
43326 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43327 }
43328 {
43329 PyThreadState* __tstate = wxPyBeginAllowThreads();
43330 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43331
43332 wxPyEndAllowThreads(__tstate);
43333 if (PyErr_Occurred()) SWIG_fail;
43334 }
43335 {
43336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43337 }
43338 return resultobj;
43339 fail:
43340 return NULL;
43341 }
43342
43343
43344 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43345 int argc;
43346 PyObject *argv[4];
43347 int ii;
43348
43349 argc = PyObject_Length(args);
43350 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43351 argv[ii] = PyTuple_GetItem(args,ii);
43352 }
43353 if (argc == 3) {
43354 int _v;
43355 {
43356 void *ptr;
43357 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43358 _v = 0;
43359 PyErr_Clear();
43360 } else {
43361 _v = 1;
43362 }
43363 }
43364 if (_v) {
43365 {
43366 void *ptr;
43367 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43368 _v = 0;
43369 PyErr_Clear();
43370 } else {
43371 _v = 1;
43372 }
43373 }
43374 if (_v) {
43375 {
43376 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43377 }
43378 if (_v) {
43379 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43380 }
43381 }
43382 }
43383 }
43384 if (argc == 3) {
43385 int _v;
43386 {
43387 void *ptr;
43388 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43389 _v = 0;
43390 PyErr_Clear();
43391 } else {
43392 _v = 1;
43393 }
43394 }
43395 if (_v) {
43396 {
43397 void *ptr;
43398 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43399 _v = 0;
43400 PyErr_Clear();
43401 } else {
43402 _v = 1;
43403 }
43404 }
43405 if (_v) {
43406 {
43407 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43408 }
43409 if (_v) {
43410 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43411 }
43412 }
43413 }
43414 }
43415 if (argc == 3) {
43416 int _v;
43417 {
43418 void *ptr;
43419 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43420 _v = 0;
43421 PyErr_Clear();
43422 } else {
43423 _v = 1;
43424 }
43425 }
43426 if (_v) {
43427 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43428 if (_v) {
43429 {
43430 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43431 }
43432 if (_v) {
43433 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43434 }
43435 }
43436 }
43437 }
43438
43439 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43440 return NULL;
43441 }
43442
43443
43444 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43445 PyObject *resultobj;
43446 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43447 wxWindow *arg2 = (wxWindow *) 0 ;
43448 wxGBSpan result;
43449 PyObject * obj0 = 0 ;
43450 PyObject * obj1 = 0 ;
43451
43452 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43454 if (SWIG_arg_fail(1)) SWIG_fail;
43455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43456 if (SWIG_arg_fail(2)) SWIG_fail;
43457 {
43458 PyThreadState* __tstate = wxPyBeginAllowThreads();
43459 result = (arg1)->GetItemSpan(arg2);
43460
43461 wxPyEndAllowThreads(__tstate);
43462 if (PyErr_Occurred()) SWIG_fail;
43463 }
43464 {
43465 wxGBSpan * resultptr;
43466 resultptr = new wxGBSpan((wxGBSpan &)(result));
43467 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43468 }
43469 return resultobj;
43470 fail:
43471 return NULL;
43472 }
43473
43474
43475 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43476 PyObject *resultobj;
43477 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43478 wxSizer *arg2 = (wxSizer *) 0 ;
43479 wxGBSpan result;
43480 PyObject * obj0 = 0 ;
43481 PyObject * obj1 = 0 ;
43482
43483 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43485 if (SWIG_arg_fail(1)) SWIG_fail;
43486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43487 if (SWIG_arg_fail(2)) SWIG_fail;
43488 {
43489 PyThreadState* __tstate = wxPyBeginAllowThreads();
43490 result = (arg1)->GetItemSpan(arg2);
43491
43492 wxPyEndAllowThreads(__tstate);
43493 if (PyErr_Occurred()) SWIG_fail;
43494 }
43495 {
43496 wxGBSpan * resultptr;
43497 resultptr = new wxGBSpan((wxGBSpan &)(result));
43498 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43499 }
43500 return resultobj;
43501 fail:
43502 return NULL;
43503 }
43504
43505
43506 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43507 PyObject *resultobj;
43508 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43509 size_t arg2 ;
43510 wxGBSpan result;
43511 PyObject * obj0 = 0 ;
43512 PyObject * obj1 = 0 ;
43513
43514 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43516 if (SWIG_arg_fail(1)) SWIG_fail;
43517 {
43518 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43519 if (SWIG_arg_fail(2)) SWIG_fail;
43520 }
43521 {
43522 PyThreadState* __tstate = wxPyBeginAllowThreads();
43523 result = (arg1)->GetItemSpan(arg2);
43524
43525 wxPyEndAllowThreads(__tstate);
43526 if (PyErr_Occurred()) SWIG_fail;
43527 }
43528 {
43529 wxGBSpan * resultptr;
43530 resultptr = new wxGBSpan((wxGBSpan &)(result));
43531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43532 }
43533 return resultobj;
43534 fail:
43535 return NULL;
43536 }
43537
43538
43539 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43540 int argc;
43541 PyObject *argv[3];
43542 int ii;
43543
43544 argc = PyObject_Length(args);
43545 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43546 argv[ii] = PyTuple_GetItem(args,ii);
43547 }
43548 if (argc == 2) {
43549 int _v;
43550 {
43551 void *ptr;
43552 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43553 _v = 0;
43554 PyErr_Clear();
43555 } else {
43556 _v = 1;
43557 }
43558 }
43559 if (_v) {
43560 {
43561 void *ptr;
43562 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43563 _v = 0;
43564 PyErr_Clear();
43565 } else {
43566 _v = 1;
43567 }
43568 }
43569 if (_v) {
43570 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43571 }
43572 }
43573 }
43574 if (argc == 2) {
43575 int _v;
43576 {
43577 void *ptr;
43578 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43579 _v = 0;
43580 PyErr_Clear();
43581 } else {
43582 _v = 1;
43583 }
43584 }
43585 if (_v) {
43586 {
43587 void *ptr;
43588 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43589 _v = 0;
43590 PyErr_Clear();
43591 } else {
43592 _v = 1;
43593 }
43594 }
43595 if (_v) {
43596 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43597 }
43598 }
43599 }
43600 if (argc == 2) {
43601 int _v;
43602 {
43603 void *ptr;
43604 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43605 _v = 0;
43606 PyErr_Clear();
43607 } else {
43608 _v = 1;
43609 }
43610 }
43611 if (_v) {
43612 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43613 if (_v) {
43614 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43615 }
43616 }
43617 }
43618
43619 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43620 return NULL;
43621 }
43622
43623
43624 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43625 PyObject *resultobj;
43626 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43627 wxWindow *arg2 = (wxWindow *) 0 ;
43628 wxGBSpan *arg3 = 0 ;
43629 bool result;
43630 wxGBSpan temp3 ;
43631 PyObject * obj0 = 0 ;
43632 PyObject * obj1 = 0 ;
43633 PyObject * obj2 = 0 ;
43634
43635 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43637 if (SWIG_arg_fail(1)) SWIG_fail;
43638 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43639 if (SWIG_arg_fail(2)) SWIG_fail;
43640 {
43641 arg3 = &temp3;
43642 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43643 }
43644 {
43645 PyThreadState* __tstate = wxPyBeginAllowThreads();
43646 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43647
43648 wxPyEndAllowThreads(__tstate);
43649 if (PyErr_Occurred()) SWIG_fail;
43650 }
43651 {
43652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43653 }
43654 return resultobj;
43655 fail:
43656 return NULL;
43657 }
43658
43659
43660 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43661 PyObject *resultobj;
43662 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43663 wxSizer *arg2 = (wxSizer *) 0 ;
43664 wxGBSpan *arg3 = 0 ;
43665 bool result;
43666 wxGBSpan temp3 ;
43667 PyObject * obj0 = 0 ;
43668 PyObject * obj1 = 0 ;
43669 PyObject * obj2 = 0 ;
43670
43671 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43673 if (SWIG_arg_fail(1)) SWIG_fail;
43674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43675 if (SWIG_arg_fail(2)) SWIG_fail;
43676 {
43677 arg3 = &temp3;
43678 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43679 }
43680 {
43681 PyThreadState* __tstate = wxPyBeginAllowThreads();
43682 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43683
43684 wxPyEndAllowThreads(__tstate);
43685 if (PyErr_Occurred()) SWIG_fail;
43686 }
43687 {
43688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43689 }
43690 return resultobj;
43691 fail:
43692 return NULL;
43693 }
43694
43695
43696 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43697 PyObject *resultobj;
43698 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43699 size_t arg2 ;
43700 wxGBSpan *arg3 = 0 ;
43701 bool result;
43702 wxGBSpan temp3 ;
43703 PyObject * obj0 = 0 ;
43704 PyObject * obj1 = 0 ;
43705 PyObject * obj2 = 0 ;
43706
43707 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43709 if (SWIG_arg_fail(1)) SWIG_fail;
43710 {
43711 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43712 if (SWIG_arg_fail(2)) SWIG_fail;
43713 }
43714 {
43715 arg3 = &temp3;
43716 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43717 }
43718 {
43719 PyThreadState* __tstate = wxPyBeginAllowThreads();
43720 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43721
43722 wxPyEndAllowThreads(__tstate);
43723 if (PyErr_Occurred()) SWIG_fail;
43724 }
43725 {
43726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43727 }
43728 return resultobj;
43729 fail:
43730 return NULL;
43731 }
43732
43733
43734 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43735 int argc;
43736 PyObject *argv[4];
43737 int ii;
43738
43739 argc = PyObject_Length(args);
43740 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43741 argv[ii] = PyTuple_GetItem(args,ii);
43742 }
43743 if (argc == 3) {
43744 int _v;
43745 {
43746 void *ptr;
43747 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43748 _v = 0;
43749 PyErr_Clear();
43750 } else {
43751 _v = 1;
43752 }
43753 }
43754 if (_v) {
43755 {
43756 void *ptr;
43757 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43758 _v = 0;
43759 PyErr_Clear();
43760 } else {
43761 _v = 1;
43762 }
43763 }
43764 if (_v) {
43765 {
43766 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43767 }
43768 if (_v) {
43769 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43770 }
43771 }
43772 }
43773 }
43774 if (argc == 3) {
43775 int _v;
43776 {
43777 void *ptr;
43778 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43779 _v = 0;
43780 PyErr_Clear();
43781 } else {
43782 _v = 1;
43783 }
43784 }
43785 if (_v) {
43786 {
43787 void *ptr;
43788 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43789 _v = 0;
43790 PyErr_Clear();
43791 } else {
43792 _v = 1;
43793 }
43794 }
43795 if (_v) {
43796 {
43797 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43798 }
43799 if (_v) {
43800 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43801 }
43802 }
43803 }
43804 }
43805 if (argc == 3) {
43806 int _v;
43807 {
43808 void *ptr;
43809 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43810 _v = 0;
43811 PyErr_Clear();
43812 } else {
43813 _v = 1;
43814 }
43815 }
43816 if (_v) {
43817 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43818 if (_v) {
43819 {
43820 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43821 }
43822 if (_v) {
43823 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43824 }
43825 }
43826 }
43827 }
43828
43829 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43830 return NULL;
43831 }
43832
43833
43834 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43835 PyObject *resultobj;
43836 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43837 wxWindow *arg2 = (wxWindow *) 0 ;
43838 wxGBSizerItem *result;
43839 PyObject * obj0 = 0 ;
43840 PyObject * obj1 = 0 ;
43841
43842 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43844 if (SWIG_arg_fail(1)) SWIG_fail;
43845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43846 if (SWIG_arg_fail(2)) SWIG_fail;
43847 {
43848 PyThreadState* __tstate = wxPyBeginAllowThreads();
43849 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43850
43851 wxPyEndAllowThreads(__tstate);
43852 if (PyErr_Occurred()) SWIG_fail;
43853 }
43854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43855 return resultobj;
43856 fail:
43857 return NULL;
43858 }
43859
43860
43861 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43862 PyObject *resultobj;
43863 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43864 wxSizer *arg2 = (wxSizer *) 0 ;
43865 wxGBSizerItem *result;
43866 PyObject * obj0 = 0 ;
43867 PyObject * obj1 = 0 ;
43868
43869 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43871 if (SWIG_arg_fail(1)) SWIG_fail;
43872 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43873 if (SWIG_arg_fail(2)) SWIG_fail;
43874 {
43875 PyThreadState* __tstate = wxPyBeginAllowThreads();
43876 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43877
43878 wxPyEndAllowThreads(__tstate);
43879 if (PyErr_Occurred()) SWIG_fail;
43880 }
43881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43882 return resultobj;
43883 fail:
43884 return NULL;
43885 }
43886
43887
43888 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43889 int argc;
43890 PyObject *argv[3];
43891 int ii;
43892
43893 argc = PyObject_Length(args);
43894 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43895 argv[ii] = PyTuple_GetItem(args,ii);
43896 }
43897 if (argc == 2) {
43898 int _v;
43899 {
43900 void *ptr;
43901 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43902 _v = 0;
43903 PyErr_Clear();
43904 } else {
43905 _v = 1;
43906 }
43907 }
43908 if (_v) {
43909 {
43910 void *ptr;
43911 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43912 _v = 0;
43913 PyErr_Clear();
43914 } else {
43915 _v = 1;
43916 }
43917 }
43918 if (_v) {
43919 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43920 }
43921 }
43922 }
43923 if (argc == 2) {
43924 int _v;
43925 {
43926 void *ptr;
43927 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43928 _v = 0;
43929 PyErr_Clear();
43930 } else {
43931 _v = 1;
43932 }
43933 }
43934 if (_v) {
43935 {
43936 void *ptr;
43937 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43938 _v = 0;
43939 PyErr_Clear();
43940 } else {
43941 _v = 1;
43942 }
43943 }
43944 if (_v) {
43945 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43946 }
43947 }
43948 }
43949
43950 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43951 return NULL;
43952 }
43953
43954
43955 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43956 PyObject *resultobj;
43957 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43958 wxGBPosition *arg2 = 0 ;
43959 wxGBSizerItem *result;
43960 wxGBPosition temp2 ;
43961 PyObject * obj0 = 0 ;
43962 PyObject * obj1 = 0 ;
43963 char *kwnames[] = {
43964 (char *) "self",(char *) "pos", NULL
43965 };
43966
43967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43969 if (SWIG_arg_fail(1)) SWIG_fail;
43970 {
43971 arg2 = &temp2;
43972 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43973 }
43974 {
43975 PyThreadState* __tstate = wxPyBeginAllowThreads();
43976 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43977
43978 wxPyEndAllowThreads(__tstate);
43979 if (PyErr_Occurred()) SWIG_fail;
43980 }
43981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43982 return resultobj;
43983 fail:
43984 return NULL;
43985 }
43986
43987
43988 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43989 PyObject *resultobj;
43990 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43991 wxPoint *arg2 = 0 ;
43992 wxGBSizerItem *result;
43993 wxPoint temp2 ;
43994 PyObject * obj0 = 0 ;
43995 PyObject * obj1 = 0 ;
43996 char *kwnames[] = {
43997 (char *) "self",(char *) "pt", NULL
43998 };
43999
44000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44002 if (SWIG_arg_fail(1)) SWIG_fail;
44003 {
44004 arg2 = &temp2;
44005 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44006 }
44007 {
44008 PyThreadState* __tstate = wxPyBeginAllowThreads();
44009 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44010
44011 wxPyEndAllowThreads(__tstate);
44012 if (PyErr_Occurred()) SWIG_fail;
44013 }
44014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44015 return resultobj;
44016 fail:
44017 return NULL;
44018 }
44019
44020
44021 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44022 PyObject *resultobj;
44023 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44024 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44025 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44026 bool result;
44027 PyObject * obj0 = 0 ;
44028 PyObject * obj1 = 0 ;
44029 PyObject * obj2 = 0 ;
44030 char *kwnames[] = {
44031 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44032 };
44033
44034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44036 if (SWIG_arg_fail(1)) SWIG_fail;
44037 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44038 if (SWIG_arg_fail(2)) SWIG_fail;
44039 if (obj2) {
44040 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44041 if (SWIG_arg_fail(3)) SWIG_fail;
44042 }
44043 {
44044 PyThreadState* __tstate = wxPyBeginAllowThreads();
44045 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44046
44047 wxPyEndAllowThreads(__tstate);
44048 if (PyErr_Occurred()) SWIG_fail;
44049 }
44050 {
44051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44052 }
44053 return resultobj;
44054 fail:
44055 return NULL;
44056 }
44057
44058
44059 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44060 PyObject *resultobj;
44061 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44062 wxGBPosition *arg2 = 0 ;
44063 wxGBSpan *arg3 = 0 ;
44064 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44065 bool result;
44066 wxGBPosition temp2 ;
44067 wxGBSpan temp3 ;
44068 PyObject * obj0 = 0 ;
44069 PyObject * obj1 = 0 ;
44070 PyObject * obj2 = 0 ;
44071 PyObject * obj3 = 0 ;
44072 char *kwnames[] = {
44073 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44074 };
44075
44076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44078 if (SWIG_arg_fail(1)) SWIG_fail;
44079 {
44080 arg2 = &temp2;
44081 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44082 }
44083 {
44084 arg3 = &temp3;
44085 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44086 }
44087 if (obj3) {
44088 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44089 if (SWIG_arg_fail(4)) SWIG_fail;
44090 }
44091 {
44092 PyThreadState* __tstate = wxPyBeginAllowThreads();
44093 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44094
44095 wxPyEndAllowThreads(__tstate);
44096 if (PyErr_Occurred()) SWIG_fail;
44097 }
44098 {
44099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44100 }
44101 return resultobj;
44102 fail:
44103 return NULL;
44104 }
44105
44106
44107 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44108 PyObject *obj;
44109 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44110 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44111 Py_INCREF(obj);
44112 return Py_BuildValue((char *)"");
44113 }
44114 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44115 PyObject *resultobj;
44116 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44117 wxRelationship arg2 ;
44118 wxWindow *arg3 = (wxWindow *) 0 ;
44119 wxEdge arg4 ;
44120 int arg5 = (int) 0 ;
44121 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44122 PyObject * obj0 = 0 ;
44123 PyObject * obj1 = 0 ;
44124 PyObject * obj2 = 0 ;
44125 PyObject * obj3 = 0 ;
44126 PyObject * obj4 = 0 ;
44127 PyObject * obj5 = 0 ;
44128 char *kwnames[] = {
44129 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44130 };
44131
44132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44134 if (SWIG_arg_fail(1)) SWIG_fail;
44135 {
44136 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44137 if (SWIG_arg_fail(2)) SWIG_fail;
44138 }
44139 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44140 if (SWIG_arg_fail(3)) SWIG_fail;
44141 {
44142 arg4 = (wxEdge)(SWIG_As_int(obj3));
44143 if (SWIG_arg_fail(4)) SWIG_fail;
44144 }
44145 if (obj4) {
44146 {
44147 arg5 = (int)(SWIG_As_int(obj4));
44148 if (SWIG_arg_fail(5)) SWIG_fail;
44149 }
44150 }
44151 if (obj5) {
44152 {
44153 arg6 = (int)(SWIG_As_int(obj5));
44154 if (SWIG_arg_fail(6)) SWIG_fail;
44155 }
44156 }
44157 {
44158 PyThreadState* __tstate = wxPyBeginAllowThreads();
44159 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44160
44161 wxPyEndAllowThreads(__tstate);
44162 if (PyErr_Occurred()) SWIG_fail;
44163 }
44164 Py_INCREF(Py_None); resultobj = Py_None;
44165 return resultobj;
44166 fail:
44167 return NULL;
44168 }
44169
44170
44171 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44172 PyObject *resultobj;
44173 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44174 wxWindow *arg2 = (wxWindow *) 0 ;
44175 int arg3 = (int) 0 ;
44176 PyObject * obj0 = 0 ;
44177 PyObject * obj1 = 0 ;
44178 PyObject * obj2 = 0 ;
44179 char *kwnames[] = {
44180 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44181 };
44182
44183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44185 if (SWIG_arg_fail(1)) SWIG_fail;
44186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44187 if (SWIG_arg_fail(2)) SWIG_fail;
44188 if (obj2) {
44189 {
44190 arg3 = (int)(SWIG_As_int(obj2));
44191 if (SWIG_arg_fail(3)) SWIG_fail;
44192 }
44193 }
44194 {
44195 PyThreadState* __tstate = wxPyBeginAllowThreads();
44196 (arg1)->LeftOf(arg2,arg3);
44197
44198 wxPyEndAllowThreads(__tstate);
44199 if (PyErr_Occurred()) SWIG_fail;
44200 }
44201 Py_INCREF(Py_None); resultobj = Py_None;
44202 return resultobj;
44203 fail:
44204 return NULL;
44205 }
44206
44207
44208 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44209 PyObject *resultobj;
44210 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44211 wxWindow *arg2 = (wxWindow *) 0 ;
44212 int arg3 = (int) 0 ;
44213 PyObject * obj0 = 0 ;
44214 PyObject * obj1 = 0 ;
44215 PyObject * obj2 = 0 ;
44216 char *kwnames[] = {
44217 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44218 };
44219
44220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44224 if (SWIG_arg_fail(2)) SWIG_fail;
44225 if (obj2) {
44226 {
44227 arg3 = (int)(SWIG_As_int(obj2));
44228 if (SWIG_arg_fail(3)) SWIG_fail;
44229 }
44230 }
44231 {
44232 PyThreadState* __tstate = wxPyBeginAllowThreads();
44233 (arg1)->RightOf(arg2,arg3);
44234
44235 wxPyEndAllowThreads(__tstate);
44236 if (PyErr_Occurred()) SWIG_fail;
44237 }
44238 Py_INCREF(Py_None); resultobj = Py_None;
44239 return resultobj;
44240 fail:
44241 return NULL;
44242 }
44243
44244
44245 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44246 PyObject *resultobj;
44247 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44248 wxWindow *arg2 = (wxWindow *) 0 ;
44249 int arg3 = (int) 0 ;
44250 PyObject * obj0 = 0 ;
44251 PyObject * obj1 = 0 ;
44252 PyObject * obj2 = 0 ;
44253 char *kwnames[] = {
44254 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44255 };
44256
44257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44259 if (SWIG_arg_fail(1)) SWIG_fail;
44260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44261 if (SWIG_arg_fail(2)) SWIG_fail;
44262 if (obj2) {
44263 {
44264 arg3 = (int)(SWIG_As_int(obj2));
44265 if (SWIG_arg_fail(3)) SWIG_fail;
44266 }
44267 }
44268 {
44269 PyThreadState* __tstate = wxPyBeginAllowThreads();
44270 (arg1)->Above(arg2,arg3);
44271
44272 wxPyEndAllowThreads(__tstate);
44273 if (PyErr_Occurred()) SWIG_fail;
44274 }
44275 Py_INCREF(Py_None); resultobj = Py_None;
44276 return resultobj;
44277 fail:
44278 return NULL;
44279 }
44280
44281
44282 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44283 PyObject *resultobj;
44284 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44285 wxWindow *arg2 = (wxWindow *) 0 ;
44286 int arg3 = (int) 0 ;
44287 PyObject * obj0 = 0 ;
44288 PyObject * obj1 = 0 ;
44289 PyObject * obj2 = 0 ;
44290 char *kwnames[] = {
44291 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44292 };
44293
44294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44296 if (SWIG_arg_fail(1)) SWIG_fail;
44297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44298 if (SWIG_arg_fail(2)) SWIG_fail;
44299 if (obj2) {
44300 {
44301 arg3 = (int)(SWIG_As_int(obj2));
44302 if (SWIG_arg_fail(3)) SWIG_fail;
44303 }
44304 }
44305 {
44306 PyThreadState* __tstate = wxPyBeginAllowThreads();
44307 (arg1)->Below(arg2,arg3);
44308
44309 wxPyEndAllowThreads(__tstate);
44310 if (PyErr_Occurred()) SWIG_fail;
44311 }
44312 Py_INCREF(Py_None); resultobj = Py_None;
44313 return resultobj;
44314 fail:
44315 return NULL;
44316 }
44317
44318
44319 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44320 PyObject *resultobj;
44321 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44322 wxWindow *arg2 = (wxWindow *) 0 ;
44323 wxEdge arg3 ;
44324 int arg4 = (int) 0 ;
44325 PyObject * obj0 = 0 ;
44326 PyObject * obj1 = 0 ;
44327 PyObject * obj2 = 0 ;
44328 PyObject * obj3 = 0 ;
44329 char *kwnames[] = {
44330 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44331 };
44332
44333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44335 if (SWIG_arg_fail(1)) SWIG_fail;
44336 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44337 if (SWIG_arg_fail(2)) SWIG_fail;
44338 {
44339 arg3 = (wxEdge)(SWIG_As_int(obj2));
44340 if (SWIG_arg_fail(3)) SWIG_fail;
44341 }
44342 if (obj3) {
44343 {
44344 arg4 = (int)(SWIG_As_int(obj3));
44345 if (SWIG_arg_fail(4)) SWIG_fail;
44346 }
44347 }
44348 {
44349 PyThreadState* __tstate = wxPyBeginAllowThreads();
44350 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44351
44352 wxPyEndAllowThreads(__tstate);
44353 if (PyErr_Occurred()) SWIG_fail;
44354 }
44355 Py_INCREF(Py_None); resultobj = Py_None;
44356 return resultobj;
44357 fail:
44358 return NULL;
44359 }
44360
44361
44362 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44363 PyObject *resultobj;
44364 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44365 wxWindow *arg2 = (wxWindow *) 0 ;
44366 wxEdge arg3 ;
44367 int arg4 ;
44368 PyObject * obj0 = 0 ;
44369 PyObject * obj1 = 0 ;
44370 PyObject * obj2 = 0 ;
44371 PyObject * obj3 = 0 ;
44372 char *kwnames[] = {
44373 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44374 };
44375
44376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44378 if (SWIG_arg_fail(1)) SWIG_fail;
44379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44380 if (SWIG_arg_fail(2)) SWIG_fail;
44381 {
44382 arg3 = (wxEdge)(SWIG_As_int(obj2));
44383 if (SWIG_arg_fail(3)) SWIG_fail;
44384 }
44385 {
44386 arg4 = (int)(SWIG_As_int(obj3));
44387 if (SWIG_arg_fail(4)) SWIG_fail;
44388 }
44389 {
44390 PyThreadState* __tstate = wxPyBeginAllowThreads();
44391 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44392
44393 wxPyEndAllowThreads(__tstate);
44394 if (PyErr_Occurred()) SWIG_fail;
44395 }
44396 Py_INCREF(Py_None); resultobj = Py_None;
44397 return resultobj;
44398 fail:
44399 return NULL;
44400 }
44401
44402
44403 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44404 PyObject *resultobj;
44405 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44406 int arg2 ;
44407 PyObject * obj0 = 0 ;
44408 PyObject * obj1 = 0 ;
44409 char *kwnames[] = {
44410 (char *) "self",(char *) "val", NULL
44411 };
44412
44413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44415 if (SWIG_arg_fail(1)) SWIG_fail;
44416 {
44417 arg2 = (int)(SWIG_As_int(obj1));
44418 if (SWIG_arg_fail(2)) SWIG_fail;
44419 }
44420 {
44421 PyThreadState* __tstate = wxPyBeginAllowThreads();
44422 (arg1)->Absolute(arg2);
44423
44424 wxPyEndAllowThreads(__tstate);
44425 if (PyErr_Occurred()) SWIG_fail;
44426 }
44427 Py_INCREF(Py_None); resultobj = Py_None;
44428 return resultobj;
44429 fail:
44430 return NULL;
44431 }
44432
44433
44434 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44435 PyObject *resultobj;
44436 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44437 PyObject * obj0 = 0 ;
44438 char *kwnames[] = {
44439 (char *) "self", NULL
44440 };
44441
44442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44444 if (SWIG_arg_fail(1)) SWIG_fail;
44445 {
44446 PyThreadState* __tstate = wxPyBeginAllowThreads();
44447 (arg1)->Unconstrained();
44448
44449 wxPyEndAllowThreads(__tstate);
44450 if (PyErr_Occurred()) SWIG_fail;
44451 }
44452 Py_INCREF(Py_None); resultobj = Py_None;
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44460 PyObject *resultobj;
44461 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44462 PyObject * obj0 = 0 ;
44463 char *kwnames[] = {
44464 (char *) "self", NULL
44465 };
44466
44467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44469 if (SWIG_arg_fail(1)) SWIG_fail;
44470 {
44471 PyThreadState* __tstate = wxPyBeginAllowThreads();
44472 (arg1)->AsIs();
44473
44474 wxPyEndAllowThreads(__tstate);
44475 if (PyErr_Occurred()) SWIG_fail;
44476 }
44477 Py_INCREF(Py_None); resultobj = Py_None;
44478 return resultobj;
44479 fail:
44480 return NULL;
44481 }
44482
44483
44484 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44485 PyObject *resultobj;
44486 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44487 wxWindow *result;
44488 PyObject * obj0 = 0 ;
44489 char *kwnames[] = {
44490 (char *) "self", NULL
44491 };
44492
44493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44495 if (SWIG_arg_fail(1)) SWIG_fail;
44496 {
44497 PyThreadState* __tstate = wxPyBeginAllowThreads();
44498 result = (wxWindow *)(arg1)->GetOtherWindow();
44499
44500 wxPyEndAllowThreads(__tstate);
44501 if (PyErr_Occurred()) SWIG_fail;
44502 }
44503 {
44504 resultobj = wxPyMake_wxObject(result, 0);
44505 }
44506 return resultobj;
44507 fail:
44508 return NULL;
44509 }
44510
44511
44512 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44513 PyObject *resultobj;
44514 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44515 wxEdge result;
44516 PyObject * obj0 = 0 ;
44517 char *kwnames[] = {
44518 (char *) "self", NULL
44519 };
44520
44521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44523 if (SWIG_arg_fail(1)) SWIG_fail;
44524 {
44525 PyThreadState* __tstate = wxPyBeginAllowThreads();
44526 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44527
44528 wxPyEndAllowThreads(__tstate);
44529 if (PyErr_Occurred()) SWIG_fail;
44530 }
44531 resultobj = SWIG_From_int((result));
44532 return resultobj;
44533 fail:
44534 return NULL;
44535 }
44536
44537
44538 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44539 PyObject *resultobj;
44540 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44541 wxEdge arg2 ;
44542 PyObject * obj0 = 0 ;
44543 PyObject * obj1 = 0 ;
44544 char *kwnames[] = {
44545 (char *) "self",(char *) "which", NULL
44546 };
44547
44548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44550 if (SWIG_arg_fail(1)) SWIG_fail;
44551 {
44552 arg2 = (wxEdge)(SWIG_As_int(obj1));
44553 if (SWIG_arg_fail(2)) SWIG_fail;
44554 }
44555 {
44556 PyThreadState* __tstate = wxPyBeginAllowThreads();
44557 (arg1)->SetEdge((wxEdge )arg2);
44558
44559 wxPyEndAllowThreads(__tstate);
44560 if (PyErr_Occurred()) SWIG_fail;
44561 }
44562 Py_INCREF(Py_None); resultobj = Py_None;
44563 return resultobj;
44564 fail:
44565 return NULL;
44566 }
44567
44568
44569 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44570 PyObject *resultobj;
44571 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44572 int arg2 ;
44573 PyObject * obj0 = 0 ;
44574 PyObject * obj1 = 0 ;
44575 char *kwnames[] = {
44576 (char *) "self",(char *) "v", NULL
44577 };
44578
44579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44581 if (SWIG_arg_fail(1)) SWIG_fail;
44582 {
44583 arg2 = (int)(SWIG_As_int(obj1));
44584 if (SWIG_arg_fail(2)) SWIG_fail;
44585 }
44586 {
44587 PyThreadState* __tstate = wxPyBeginAllowThreads();
44588 (arg1)->SetValue(arg2);
44589
44590 wxPyEndAllowThreads(__tstate);
44591 if (PyErr_Occurred()) SWIG_fail;
44592 }
44593 Py_INCREF(Py_None); resultobj = Py_None;
44594 return resultobj;
44595 fail:
44596 return NULL;
44597 }
44598
44599
44600 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44601 PyObject *resultobj;
44602 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44603 int result;
44604 PyObject * obj0 = 0 ;
44605 char *kwnames[] = {
44606 (char *) "self", NULL
44607 };
44608
44609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44611 if (SWIG_arg_fail(1)) SWIG_fail;
44612 {
44613 PyThreadState* __tstate = wxPyBeginAllowThreads();
44614 result = (int)(arg1)->GetMargin();
44615
44616 wxPyEndAllowThreads(__tstate);
44617 if (PyErr_Occurred()) SWIG_fail;
44618 }
44619 {
44620 resultobj = SWIG_From_int((int)(result));
44621 }
44622 return resultobj;
44623 fail:
44624 return NULL;
44625 }
44626
44627
44628 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44629 PyObject *resultobj;
44630 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44631 int arg2 ;
44632 PyObject * obj0 = 0 ;
44633 PyObject * obj1 = 0 ;
44634 char *kwnames[] = {
44635 (char *) "self",(char *) "m", NULL
44636 };
44637
44638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44640 if (SWIG_arg_fail(1)) SWIG_fail;
44641 {
44642 arg2 = (int)(SWIG_As_int(obj1));
44643 if (SWIG_arg_fail(2)) SWIG_fail;
44644 }
44645 {
44646 PyThreadState* __tstate = wxPyBeginAllowThreads();
44647 (arg1)->SetMargin(arg2);
44648
44649 wxPyEndAllowThreads(__tstate);
44650 if (PyErr_Occurred()) SWIG_fail;
44651 }
44652 Py_INCREF(Py_None); resultobj = Py_None;
44653 return resultobj;
44654 fail:
44655 return NULL;
44656 }
44657
44658
44659 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44660 PyObject *resultobj;
44661 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44662 int result;
44663 PyObject * obj0 = 0 ;
44664 char *kwnames[] = {
44665 (char *) "self", NULL
44666 };
44667
44668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44670 if (SWIG_arg_fail(1)) SWIG_fail;
44671 {
44672 PyThreadState* __tstate = wxPyBeginAllowThreads();
44673 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44674
44675 wxPyEndAllowThreads(__tstate);
44676 if (PyErr_Occurred()) SWIG_fail;
44677 }
44678 {
44679 resultobj = SWIG_From_int((int)(result));
44680 }
44681 return resultobj;
44682 fail:
44683 return NULL;
44684 }
44685
44686
44687 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44688 PyObject *resultobj;
44689 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44690 int result;
44691 PyObject * obj0 = 0 ;
44692 char *kwnames[] = {
44693 (char *) "self", NULL
44694 };
44695
44696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44698 if (SWIG_arg_fail(1)) SWIG_fail;
44699 {
44700 PyThreadState* __tstate = wxPyBeginAllowThreads();
44701 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44702
44703 wxPyEndAllowThreads(__tstate);
44704 if (PyErr_Occurred()) SWIG_fail;
44705 }
44706 {
44707 resultobj = SWIG_From_int((int)(result));
44708 }
44709 return resultobj;
44710 fail:
44711 return NULL;
44712 }
44713
44714
44715 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44716 PyObject *resultobj;
44717 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44718 int result;
44719 PyObject * obj0 = 0 ;
44720 char *kwnames[] = {
44721 (char *) "self", NULL
44722 };
44723
44724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44726 if (SWIG_arg_fail(1)) SWIG_fail;
44727 {
44728 PyThreadState* __tstate = wxPyBeginAllowThreads();
44729 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44730
44731 wxPyEndAllowThreads(__tstate);
44732 if (PyErr_Occurred()) SWIG_fail;
44733 }
44734 {
44735 resultobj = SWIG_From_int((int)(result));
44736 }
44737 return resultobj;
44738 fail:
44739 return NULL;
44740 }
44741
44742
44743 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44744 PyObject *resultobj;
44745 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44746 bool result;
44747 PyObject * obj0 = 0 ;
44748 char *kwnames[] = {
44749 (char *) "self", NULL
44750 };
44751
44752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44754 if (SWIG_arg_fail(1)) SWIG_fail;
44755 {
44756 PyThreadState* __tstate = wxPyBeginAllowThreads();
44757 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44758
44759 wxPyEndAllowThreads(__tstate);
44760 if (PyErr_Occurred()) SWIG_fail;
44761 }
44762 {
44763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44764 }
44765 return resultobj;
44766 fail:
44767 return NULL;
44768 }
44769
44770
44771 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44772 PyObject *resultobj;
44773 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44774 bool arg2 ;
44775 PyObject * obj0 = 0 ;
44776 PyObject * obj1 = 0 ;
44777 char *kwnames[] = {
44778 (char *) "self",(char *) "d", NULL
44779 };
44780
44781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44783 if (SWIG_arg_fail(1)) SWIG_fail;
44784 {
44785 arg2 = (bool)(SWIG_As_bool(obj1));
44786 if (SWIG_arg_fail(2)) SWIG_fail;
44787 }
44788 {
44789 PyThreadState* __tstate = wxPyBeginAllowThreads();
44790 (arg1)->SetDone(arg2);
44791
44792 wxPyEndAllowThreads(__tstate);
44793 if (PyErr_Occurred()) SWIG_fail;
44794 }
44795 Py_INCREF(Py_None); resultobj = Py_None;
44796 return resultobj;
44797 fail:
44798 return NULL;
44799 }
44800
44801
44802 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44803 PyObject *resultobj;
44804 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44805 wxRelationship result;
44806 PyObject * obj0 = 0 ;
44807 char *kwnames[] = {
44808 (char *) "self", NULL
44809 };
44810
44811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44813 if (SWIG_arg_fail(1)) SWIG_fail;
44814 {
44815 PyThreadState* __tstate = wxPyBeginAllowThreads();
44816 result = (wxRelationship)(arg1)->GetRelationship();
44817
44818 wxPyEndAllowThreads(__tstate);
44819 if (PyErr_Occurred()) SWIG_fail;
44820 }
44821 resultobj = SWIG_From_int((result));
44822 return resultobj;
44823 fail:
44824 return NULL;
44825 }
44826
44827
44828 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44829 PyObject *resultobj;
44830 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44831 wxRelationship arg2 ;
44832 PyObject * obj0 = 0 ;
44833 PyObject * obj1 = 0 ;
44834 char *kwnames[] = {
44835 (char *) "self",(char *) "r", NULL
44836 };
44837
44838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44840 if (SWIG_arg_fail(1)) SWIG_fail;
44841 {
44842 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44843 if (SWIG_arg_fail(2)) SWIG_fail;
44844 }
44845 {
44846 PyThreadState* __tstate = wxPyBeginAllowThreads();
44847 (arg1)->SetRelationship((wxRelationship )arg2);
44848
44849 wxPyEndAllowThreads(__tstate);
44850 if (PyErr_Occurred()) SWIG_fail;
44851 }
44852 Py_INCREF(Py_None); resultobj = Py_None;
44853 return resultobj;
44854 fail:
44855 return NULL;
44856 }
44857
44858
44859 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44860 PyObject *resultobj;
44861 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44862 wxWindow *arg2 = (wxWindow *) 0 ;
44863 bool result;
44864 PyObject * obj0 = 0 ;
44865 PyObject * obj1 = 0 ;
44866 char *kwnames[] = {
44867 (char *) "self",(char *) "otherW", NULL
44868 };
44869
44870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44872 if (SWIG_arg_fail(1)) SWIG_fail;
44873 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44874 if (SWIG_arg_fail(2)) SWIG_fail;
44875 {
44876 PyThreadState* __tstate = wxPyBeginAllowThreads();
44877 result = (bool)(arg1)->ResetIfWin(arg2);
44878
44879 wxPyEndAllowThreads(__tstate);
44880 if (PyErr_Occurred()) SWIG_fail;
44881 }
44882 {
44883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44884 }
44885 return resultobj;
44886 fail:
44887 return NULL;
44888 }
44889
44890
44891 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44892 PyObject *resultobj;
44893 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44894 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44895 wxWindow *arg3 = (wxWindow *) 0 ;
44896 bool result;
44897 PyObject * obj0 = 0 ;
44898 PyObject * obj1 = 0 ;
44899 PyObject * obj2 = 0 ;
44900 char *kwnames[] = {
44901 (char *) "self",(char *) "constraints",(char *) "win", NULL
44902 };
44903
44904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44906 if (SWIG_arg_fail(1)) SWIG_fail;
44907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44908 if (SWIG_arg_fail(2)) SWIG_fail;
44909 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44910 if (SWIG_arg_fail(3)) SWIG_fail;
44911 {
44912 PyThreadState* __tstate = wxPyBeginAllowThreads();
44913 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44914
44915 wxPyEndAllowThreads(__tstate);
44916 if (PyErr_Occurred()) SWIG_fail;
44917 }
44918 {
44919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44920 }
44921 return resultobj;
44922 fail:
44923 return NULL;
44924 }
44925
44926
44927 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44928 PyObject *resultobj;
44929 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44930 wxEdge arg2 ;
44931 wxWindow *arg3 = (wxWindow *) 0 ;
44932 wxWindow *arg4 = (wxWindow *) 0 ;
44933 int result;
44934 PyObject * obj0 = 0 ;
44935 PyObject * obj1 = 0 ;
44936 PyObject * obj2 = 0 ;
44937 PyObject * obj3 = 0 ;
44938 char *kwnames[] = {
44939 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44940 };
44941
44942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44944 if (SWIG_arg_fail(1)) SWIG_fail;
44945 {
44946 arg2 = (wxEdge)(SWIG_As_int(obj1));
44947 if (SWIG_arg_fail(2)) SWIG_fail;
44948 }
44949 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44950 if (SWIG_arg_fail(3)) SWIG_fail;
44951 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44952 if (SWIG_arg_fail(4)) SWIG_fail;
44953 {
44954 PyThreadState* __tstate = wxPyBeginAllowThreads();
44955 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44956
44957 wxPyEndAllowThreads(__tstate);
44958 if (PyErr_Occurred()) SWIG_fail;
44959 }
44960 {
44961 resultobj = SWIG_From_int((int)(result));
44962 }
44963 return resultobj;
44964 fail:
44965 return NULL;
44966 }
44967
44968
44969 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44970 PyObject *obj;
44971 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44972 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44973 Py_INCREF(obj);
44974 return Py_BuildValue((char *)"");
44975 }
44976 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44977 PyObject *resultobj;
44978 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44979 wxIndividualLayoutConstraint *result;
44980 PyObject * obj0 = 0 ;
44981 char *kwnames[] = {
44982 (char *) "self", NULL
44983 };
44984
44985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44987 if (SWIG_arg_fail(1)) SWIG_fail;
44988 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44989
44990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44991 return resultobj;
44992 fail:
44993 return NULL;
44994 }
44995
44996
44997 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44998 PyObject *resultobj;
44999 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45000 wxIndividualLayoutConstraint *result;
45001 PyObject * obj0 = 0 ;
45002 char *kwnames[] = {
45003 (char *) "self", NULL
45004 };
45005
45006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45008 if (SWIG_arg_fail(1)) SWIG_fail;
45009 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45010
45011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45012 return resultobj;
45013 fail:
45014 return NULL;
45015 }
45016
45017
45018 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45019 PyObject *resultobj;
45020 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45021 wxIndividualLayoutConstraint *result;
45022 PyObject * obj0 = 0 ;
45023 char *kwnames[] = {
45024 (char *) "self", NULL
45025 };
45026
45027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45029 if (SWIG_arg_fail(1)) SWIG_fail;
45030 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45031
45032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45033 return resultobj;
45034 fail:
45035 return NULL;
45036 }
45037
45038
45039 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45040 PyObject *resultobj;
45041 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45042 wxIndividualLayoutConstraint *result;
45043 PyObject * obj0 = 0 ;
45044 char *kwnames[] = {
45045 (char *) "self", NULL
45046 };
45047
45048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45050 if (SWIG_arg_fail(1)) SWIG_fail;
45051 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45052
45053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45054 return resultobj;
45055 fail:
45056 return NULL;
45057 }
45058
45059
45060 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45061 PyObject *resultobj;
45062 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45063 wxIndividualLayoutConstraint *result;
45064 PyObject * obj0 = 0 ;
45065 char *kwnames[] = {
45066 (char *) "self", NULL
45067 };
45068
45069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45071 if (SWIG_arg_fail(1)) SWIG_fail;
45072 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45073
45074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45075 return resultobj;
45076 fail:
45077 return NULL;
45078 }
45079
45080
45081 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45082 PyObject *resultobj;
45083 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45084 wxIndividualLayoutConstraint *result;
45085 PyObject * obj0 = 0 ;
45086 char *kwnames[] = {
45087 (char *) "self", NULL
45088 };
45089
45090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45092 if (SWIG_arg_fail(1)) SWIG_fail;
45093 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45094
45095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45096 return resultobj;
45097 fail:
45098 return NULL;
45099 }
45100
45101
45102 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45103 PyObject *resultobj;
45104 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45105 wxIndividualLayoutConstraint *result;
45106 PyObject * obj0 = 0 ;
45107 char *kwnames[] = {
45108 (char *) "self", NULL
45109 };
45110
45111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45113 if (SWIG_arg_fail(1)) SWIG_fail;
45114 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45115
45116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45117 return resultobj;
45118 fail:
45119 return NULL;
45120 }
45121
45122
45123 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45124 PyObject *resultobj;
45125 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45126 wxIndividualLayoutConstraint *result;
45127 PyObject * obj0 = 0 ;
45128 char *kwnames[] = {
45129 (char *) "self", NULL
45130 };
45131
45132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45134 if (SWIG_arg_fail(1)) SWIG_fail;
45135 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45136
45137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45138 return resultobj;
45139 fail:
45140 return NULL;
45141 }
45142
45143
45144 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45145 PyObject *resultobj;
45146 wxLayoutConstraints *result;
45147 char *kwnames[] = {
45148 NULL
45149 };
45150
45151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45152 {
45153 PyThreadState* __tstate = wxPyBeginAllowThreads();
45154 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45155
45156 wxPyEndAllowThreads(__tstate);
45157 if (PyErr_Occurred()) SWIG_fail;
45158 }
45159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45160 return resultobj;
45161 fail:
45162 return NULL;
45163 }
45164
45165
45166 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45167 PyObject *resultobj;
45168 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45169 wxWindow *arg2 = (wxWindow *) 0 ;
45170 int *arg3 = (int *) 0 ;
45171 bool result;
45172 int temp3 ;
45173 int res3 = 0 ;
45174 PyObject * obj0 = 0 ;
45175 PyObject * obj1 = 0 ;
45176 char *kwnames[] = {
45177 (char *) "self",(char *) "win", NULL
45178 };
45179
45180 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45183 if (SWIG_arg_fail(1)) SWIG_fail;
45184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45185 if (SWIG_arg_fail(2)) SWIG_fail;
45186 {
45187 PyThreadState* __tstate = wxPyBeginAllowThreads();
45188 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45189
45190 wxPyEndAllowThreads(__tstate);
45191 if (PyErr_Occurred()) SWIG_fail;
45192 }
45193 {
45194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45195 }
45196 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45197 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45198 return resultobj;
45199 fail:
45200 return NULL;
45201 }
45202
45203
45204 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45205 PyObject *resultobj;
45206 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45207 bool result;
45208 PyObject * obj0 = 0 ;
45209 char *kwnames[] = {
45210 (char *) "self", NULL
45211 };
45212
45213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45215 if (SWIG_arg_fail(1)) SWIG_fail;
45216 {
45217 PyThreadState* __tstate = wxPyBeginAllowThreads();
45218 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45219
45220 wxPyEndAllowThreads(__tstate);
45221 if (PyErr_Occurred()) SWIG_fail;
45222 }
45223 {
45224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45225 }
45226 return resultobj;
45227 fail:
45228 return NULL;
45229 }
45230
45231
45232 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45233 PyObject *obj;
45234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45235 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45236 Py_INCREF(obj);
45237 return Py_BuildValue((char *)"");
45238 }
45239 static PyMethodDef SwigMethods[] = {
45240 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45241 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45242 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45245 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45266 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45279 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45294 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45348 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45376 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45395 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45397 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45405 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45406 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45418 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45430 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45434 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45440 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45450 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45460 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45467 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45546 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45548 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45550 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45552 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45554 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45556 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45558 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45560 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45562 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45564 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45566 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45568 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45570 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45584 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45602 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45605 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45608 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45620 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45625 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45631 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45637 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45700 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45707 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45743 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45753 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45759 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45761 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45763 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45766 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45770 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45773 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45776 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45778 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45783 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45791 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45795 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45798 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45800 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45804 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45821 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45823 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45826 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45828 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45832 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45836 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45847 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45850 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45853 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45857 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45864 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45869 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45874 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45878 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45923 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45943 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45950 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45954 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45964 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46136 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46178 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46192 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46195 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46250 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46277 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46321 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46329 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46348 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46349 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46386 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46416 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46419 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46423 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46426 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46436 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46448 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46460 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46470 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46480 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46494 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46501 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46502 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46503 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46504 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46505 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46510 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46537 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46549 { NULL, NULL, 0, NULL }
46550 };
46551
46552
46553 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46554
46555 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46556 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46557 }
46558 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46559 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46560 }
46561 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46562 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46563 }
46564 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46565 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46566 }
46567 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46568 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46569 }
46570 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46571 return (void *)((wxSizer *) ((wxGridSizer *) x));
46572 }
46573 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46574 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46575 }
46576 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46577 return (void *)((wxSizer *) ((wxPySizer *) x));
46578 }
46579 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46580 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46581 }
46582 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46583 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46584 }
46585 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46586 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46587 }
46588 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46589 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46590 }
46591 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46592 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46593 }
46594 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46595 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46596 }
46597 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46598 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46599 }
46600 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46601 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46602 }
46603 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46604 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46605 }
46606 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46607 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46608 }
46609 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46610 return (void *)((wxEvent *) ((wxPyEvent *) x));
46611 }
46612 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46613 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46614 }
46615 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46616 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46617 }
46618 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46619 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46620 }
46621 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46622 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46623 }
46624 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46625 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46626 }
46627 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46628 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46629 }
46630 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46631 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46632 }
46633 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46634 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46635 }
46636 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46637 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46638 }
46639 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46640 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46641 }
46642 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46643 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46644 }
46645 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46646 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46647 }
46648 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46649 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46650 }
46651 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46652 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46653 }
46654 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46655 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46656 }
46657 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46658 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46659 }
46660 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46661 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46662 }
46663 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46664 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46665 }
46666 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46667 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46668 }
46669 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46670 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46671 }
46672 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46673 return (void *)((wxEvent *) ((wxShowEvent *) x));
46674 }
46675 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46676 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46677 }
46678 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46679 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46680 }
46681 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46682 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46683 }
46684 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46685 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46686 }
46687 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46688 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46689 }
46690 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46691 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46692 }
46693 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46694 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46695 }
46696 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46697 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46698 }
46699 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46700 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46701 }
46702 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46703 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46704 }
46705 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46706 return (void *)((wxControl *) ((wxControlWithItems *) x));
46707 }
46708 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46709 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46710 }
46711 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46712 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46713 }
46714 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46715 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46716 }
46717 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46718 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46719 }
46720 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46721 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46722 }
46723 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46724 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46725 }
46726 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46727 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46728 }
46729 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46730 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46731 }
46732 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46733 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46734 }
46735 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46736 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46737 }
46738 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46739 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46740 }
46741 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46742 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46743 }
46744 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46745 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46746 }
46747 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46748 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46749 }
46750 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46751 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46752 }
46753 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46754 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46755 }
46756 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46757 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46758 }
46759 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46760 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46761 }
46762 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46763 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46764 }
46765 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46766 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46767 }
46768 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46769 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46770 }
46771 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46772 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46773 }
46774 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46775 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46776 }
46777 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46778 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46779 }
46780 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46781 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46782 }
46783 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46784 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46785 }
46786 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46787 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46788 }
46789 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46790 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46791 }
46792 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46793 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46794 }
46795 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46796 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46797 }
46798 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46799 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46800 }
46801 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46802 return (void *)((wxObject *) ((wxSizerItem *) x));
46803 }
46804 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46805 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46806 }
46807 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46808 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46809 }
46810 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46811 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46812 }
46813 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46814 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46815 }
46816 static void *_p_wxSizerTo_p_wxObject(void *x) {
46817 return (void *)((wxObject *) ((wxSizer *) x));
46818 }
46819 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46820 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46821 }
46822 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46823 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46824 }
46825 static void *_p_wxEventTo_p_wxObject(void *x) {
46826 return (void *)((wxObject *) ((wxEvent *) x));
46827 }
46828 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46829 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46830 }
46831 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46832 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46833 }
46834 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46835 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46836 }
46837 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46838 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46839 }
46840 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46841 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46842 }
46843 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46844 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46845 }
46846 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46847 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46848 }
46849 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46850 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46851 }
46852 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46853 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46854 }
46855 static void *_p_wxControlTo_p_wxObject(void *x) {
46856 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46857 }
46858 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46859 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46860 }
46861 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46862 return (void *)((wxObject *) ((wxFSFile *) x));
46863 }
46864 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46865 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46866 }
46867 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46868 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46869 }
46870 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46871 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46872 }
46873 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46874 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46875 }
46876 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46877 return (void *)((wxObject *) ((wxMenuItem *) x));
46878 }
46879 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46880 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46881 }
46882 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46883 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46884 }
46885 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46886 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46887 }
46888 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46889 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46890 }
46891 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46892 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46893 }
46894 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46895 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46896 }
46897 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46898 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46899 }
46900 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46901 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46902 }
46903 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46904 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46905 }
46906 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46907 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46908 }
46909 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46910 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46911 }
46912 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46913 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46914 }
46915 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46916 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46917 }
46918 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46919 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46920 }
46921 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46922 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46923 }
46924 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46925 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46926 }
46927 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46928 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46929 }
46930 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46931 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46932 }
46933 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46934 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46935 }
46936 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46937 return (void *)((wxObject *) ((wxImageHandler *) x));
46938 }
46939 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46940 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46941 }
46942 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46943 return (void *)((wxObject *) ((wxEvtHandler *) x));
46944 }
46945 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46946 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46947 }
46948 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46949 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46950 }
46951 static void *_p_wxImageTo_p_wxObject(void *x) {
46952 return (void *)((wxObject *) ((wxImage *) x));
46953 }
46954 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46955 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46956 }
46957 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46958 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46959 }
46960 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46961 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46962 }
46963 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46964 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46965 }
46966 static void *_p_wxWindowTo_p_wxObject(void *x) {
46967 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46968 }
46969 static void *_p_wxMenuTo_p_wxObject(void *x) {
46970 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46971 }
46972 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46973 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46974 }
46975 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46976 return (void *)((wxObject *) ((wxFileSystem *) x));
46977 }
46978 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46979 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46980 }
46981 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46982 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46983 }
46984 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46985 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46986 }
46987 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46988 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46989 }
46990 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46991 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46992 }
46993 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46994 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46995 }
46996 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46997 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46998 }
46999 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47000 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47001 }
47002 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47003 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47004 }
47005 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47006 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47007 }
47008 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47009 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47010 }
47011 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47012 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47013 }
47014 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47015 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47016 }
47017 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47018 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47019 }
47020 static void *_p_wxControlTo_p_wxWindow(void *x) {
47021 return (void *)((wxWindow *) ((wxControl *) x));
47022 }
47023 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47024 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47025 }
47026 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47027 return (void *)((wxWindow *) ((wxMenuBar *) x));
47028 }
47029 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47030 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47031 }
47032 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47033 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47034 }
47035 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47036 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47037 }
47038 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47039 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47040 }
47041 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47042 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47043 }
47044 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47045 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47046 }
47047 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47048 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47049 }
47050 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47051 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47052 }
47053 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47054 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47055 }
47056 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47057 return (void *)((wxValidator *) ((wxPyValidator *) x));
47058 }
47059 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}};
47060 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}};
47061 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}};
47062 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}};
47063 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}};
47064 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}};
47065 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}};
47066 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}};
47067 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}};
47068 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}};
47069 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}};
47070 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}};
47071 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}};
47072 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}};
47073 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}};
47074 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}};
47075 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}};
47076 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}};
47077 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}};
47078 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}};
47079 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}};
47080 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}};
47081 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}};
47082 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}};
47083 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}};
47084 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}};
47085 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}};
47086 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}};
47087 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}};
47088 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}};
47089 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}};
47090 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}};
47091 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}};
47092 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}};
47093 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}};
47094 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}};
47095 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}};
47096 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}};
47097 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}};
47098 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}};
47099 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}};
47100 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}};
47101 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}};
47102 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}};
47103 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}};
47104 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}};
47105 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}};
47106 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}};
47107 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}};
47108 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}};
47109 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}};
47110 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}};
47111 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}};
47112 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}};
47113 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}};
47114 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}};
47115 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}};
47116 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}};
47117 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}};
47118 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}};
47119 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}};
47120 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}};
47121 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}};
47122 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}};
47123 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}};
47124 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}};
47125 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}};
47126 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}};
47127 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}};
47128 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}};
47129 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}};
47130 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}};
47131 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}};
47132 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}};
47133 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}};
47134 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}};
47135 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}};
47136 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}};
47137 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}};
47138 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}};
47139 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}};
47140 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}};
47141 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}};
47142 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}};
47143 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}};
47144 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}};
47145 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}};
47146 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}};
47147 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}};
47148 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}};
47149 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}};
47150 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}};
47151 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}};
47152 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}};
47153 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}};
47154 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}};
47155 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}};
47156 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}};
47157 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}};
47158 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}};
47159 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}};
47160 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}};
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 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}};
47166 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}};
47167 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}};
47168 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}};
47169 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}};
47170 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186
47187 static swig_type_info *swig_types_initial[] = {
47188 _swigt__p_wxLayoutConstraints,
47189 _swigt__p_wxRealPoint,
47190 _swigt__p_wxSizerItem,
47191 _swigt__p_wxGBSizerItem,
47192 _swigt__p_wxScrollEvent,
47193 _swigt__p_wxEventLoop,
47194 _swigt__p_wxIndividualLayoutConstraint,
47195 _swigt__p_wxSizer,
47196 _swigt__p_wxBoxSizer,
47197 _swigt__p_wxStaticBoxSizer,
47198 _swigt__p_wxGridBagSizer,
47199 _swigt__p_wxAcceleratorEntry,
47200 _swigt__p_wxUpdateUIEvent,
47201 _swigt__p_wxEvent,
47202 _swigt__p_wxMenu,
47203 _swigt__p_wxGridSizer,
47204 _swigt__p_wxFlexGridSizer,
47205 _swigt__p_wxInitDialogEvent,
47206 _swigt__p_wxItemContainer,
47207 _swigt__p_wxNcPaintEvent,
47208 _swigt__p_wxPaintEvent,
47209 _swigt__p_wxSysColourChangedEvent,
47210 _swigt__p_wxMouseCaptureChangedEvent,
47211 _swigt__p_wxDisplayChangedEvent,
47212 _swigt__p_wxPaletteChangedEvent,
47213 _swigt__p_wxControl,
47214 _swigt__p_wxFont,
47215 _swigt__p_wxMenuBarBase,
47216 _swigt__p_wxSetCursorEvent,
47217 _swigt__p_wxFSFile,
47218 _swigt__p_wxCaret,
47219 _swigt__ptrdiff_t,
47220 _swigt__std__ptrdiff_t,
47221 _swigt__p_wxRegion,
47222 _swigt__p_wxPoint2D,
47223 _swigt__p_int,
47224 _swigt__p_wxSize,
47225 _swigt__p_wxDC,
47226 _swigt__p_wxPySizer,
47227 _swigt__p_wxVisualAttributes,
47228 _swigt__p_wxNotifyEvent,
47229 _swigt__p_wxPyEvent,
47230 _swigt__p_wxPropagationDisabler,
47231 _swigt__p_form_ops_t,
47232 _swigt__p_wxAppTraits,
47233 _swigt__p_wxArrayString,
47234 _swigt__p_wxShowEvent,
47235 _swigt__p_wxToolTip,
47236 _swigt__p_wxMoveEvent,
47237 _swigt__p_wxSizeEvent,
47238 _swigt__p_wxActivateEvent,
47239 _swigt__p_wxIconizeEvent,
47240 _swigt__p_wxMaximizeEvent,
47241 _swigt__p_wxQueryNewPaletteEvent,
47242 _swigt__p_wxWindowCreateEvent,
47243 _swigt__p_wxIdleEvent,
47244 _swigt__p_wxDateEvent,
47245 _swigt__p_wxMenuItem,
47246 _swigt__p_wxStaticBox,
47247 _swigt__p_long,
47248 _swigt__p_wxDuplexMode,
47249 _swigt__p_wxTIFFHandler,
47250 _swigt__p_wxXPMHandler,
47251 _swigt__p_wxPNMHandler,
47252 _swigt__p_wxJPEGHandler,
47253 _swigt__p_wxPCXHandler,
47254 _swigt__p_wxGIFHandler,
47255 _swigt__p_wxPNGHandler,
47256 _swigt__p_wxANIHandler,
47257 _swigt__p_wxMemoryFSHandler,
47258 _swigt__p_wxZipFSHandler,
47259 _swigt__p_wxInternetFSHandler,
47260 _swigt__p_wxPyFileSystemHandler,
47261 _swigt__p_wxEvtHandler,
47262 _swigt__p_wxCURHandler,
47263 _swigt__p_wxICOHandler,
47264 _swigt__p_wxBMPHandler,
47265 _swigt__p_wxImageHandler,
47266 _swigt__p_wxFileSystemHandler,
47267 _swigt__p_wxRect,
47268 _swigt__p_wxButton,
47269 _swigt__p_wxGBSpan,
47270 _swigt__p_wxPropagateOnce,
47271 _swigt__p_wxAcceleratorTable,
47272 _swigt__p_wxStdDialogButtonSizer,
47273 _swigt__p_char,
47274 _swigt__p_wxGBPosition,
47275 _swigt__p_wxImage,
47276 _swigt__p_wxFrame,
47277 _swigt__p_wxScrollWinEvent,
47278 _swigt__p_wxPaperSize,
47279 _swigt__p_wxImageHistogram,
47280 _swigt__p_wxPoint,
47281 _swigt__p_wxCursor,
47282 _swigt__p_wxObject,
47283 _swigt__p_wxInputStream,
47284 _swigt__p_wxOutputStream,
47285 _swigt__p_wxPyInputStream,
47286 _swigt__p_wxDateTime,
47287 _swigt__p_wxKeyEvent,
47288 _swigt__p_wxNavigationKeyEvent,
47289 _swigt__p_wxWindowDestroyEvent,
47290 _swigt__p_unsigned_long,
47291 _swigt__p_wxWindow,
47292 _swigt__p_wxMenuBar,
47293 _swigt__p_wxFileSystem,
47294 _swigt__p_wxBitmap,
47295 _swigt__unsigned_int,
47296 _swigt__p_unsigned_int,
47297 _swigt__p_wxMenuEvent,
47298 _swigt__p_wxContextMenuEvent,
47299 _swigt__p_unsigned_char,
47300 _swigt__p_wxEraseEvent,
47301 _swigt__p_wxMouseEvent,
47302 _swigt__p_wxCloseEvent,
47303 _swigt__p_wxPyApp,
47304 _swigt__p_wxCommandEvent,
47305 _swigt__p_wxPyCommandEvent,
47306 _swigt__p_wxPyDropTarget,
47307 _swigt__p_wxQuantize,
47308 _swigt__p_wxChildFocusEvent,
47309 _swigt__p_wxFocusEvent,
47310 _swigt__p_wxDropFilesEvent,
47311 _swigt__p_wxControlWithItems,
47312 _swigt__p_wxColour,
47313 _swigt__p_wxValidator,
47314 _swigt__p_wxPyValidator,
47315 0
47316 };
47317
47318
47319 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47320
47321 static swig_const_info swig_const_table[] = {
47322 {0, 0, 0, 0.0, 0, 0}};
47323
47324 #ifdef __cplusplus
47325 }
47326 #endif
47327
47328
47329 #ifdef __cplusplus
47330 extern "C" {
47331 #endif
47332
47333 /* Python-specific SWIG API */
47334 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47335 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47336 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47337
47338 /* -----------------------------------------------------------------------------
47339 * global variable support code.
47340 * ----------------------------------------------------------------------------- */
47341
47342 typedef struct swig_globalvar {
47343 char *name; /* Name of global variable */
47344 PyObject *(*get_attr)(); /* Return the current value */
47345 int (*set_attr)(PyObject *); /* Set the value */
47346 struct swig_globalvar *next;
47347 } swig_globalvar;
47348
47349 typedef struct swig_varlinkobject {
47350 PyObject_HEAD
47351 swig_globalvar *vars;
47352 } swig_varlinkobject;
47353
47354 static PyObject *
47355 swig_varlink_repr(swig_varlinkobject *v) {
47356 v = v;
47357 return PyString_FromString("<Swig global variables>");
47358 }
47359
47360 static int
47361 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47362 swig_globalvar *var;
47363 flags = flags;
47364 fprintf(fp,"Swig global variables { ");
47365 for (var = v->vars; var; var=var->next) {
47366 fprintf(fp,"%s", var->name);
47367 if (var->next) fprintf(fp,", ");
47368 }
47369 fprintf(fp," }\n");
47370 return 0;
47371 }
47372
47373 static PyObject *
47374 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47375 swig_globalvar *var = v->vars;
47376 while (var) {
47377 if (strcmp(var->name,n) == 0) {
47378 return (*var->get_attr)();
47379 }
47380 var = var->next;
47381 }
47382 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47383 return NULL;
47384 }
47385
47386 static int
47387 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47388 swig_globalvar *var = v->vars;
47389 while (var) {
47390 if (strcmp(var->name,n) == 0) {
47391 return (*var->set_attr)(p);
47392 }
47393 var = var->next;
47394 }
47395 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47396 return 1;
47397 }
47398
47399 static PyTypeObject varlinktype = {
47400 PyObject_HEAD_INIT(0)
47401 0, /* Number of items in variable part (ob_size) */
47402 (char *)"swigvarlink", /* Type name (tp_name) */
47403 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47404 0, /* Itemsize (tp_itemsize) */
47405 0, /* Deallocator (tp_dealloc) */
47406 (printfunc) swig_varlink_print, /* Print (tp_print) */
47407 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47408 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47409 0, /* tp_compare */
47410 (reprfunc) swig_varlink_repr, /* tp_repr */
47411 0, /* tp_as_number */
47412 0, /* tp_as_sequence */
47413 0, /* tp_as_mapping */
47414 0, /* tp_hash */
47415 0, /* tp_call */
47416 0, /* tp_str */
47417 0, /* tp_getattro */
47418 0, /* tp_setattro */
47419 0, /* tp_as_buffer */
47420 0, /* tp_flags */
47421 0, /* tp_doc */
47422 #if PY_VERSION_HEX >= 0x02000000
47423 0, /* tp_traverse */
47424 0, /* tp_clear */
47425 #endif
47426 #if PY_VERSION_HEX >= 0x02010000
47427 0, /* tp_richcompare */
47428 0, /* tp_weaklistoffset */
47429 #endif
47430 #if PY_VERSION_HEX >= 0x02020000
47431 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47432 #endif
47433 #if PY_VERSION_HEX >= 0x02030000
47434 0, /* tp_del */
47435 #endif
47436 #ifdef COUNT_ALLOCS
47437 0,0,0,0 /* tp_alloc -> tp_next */
47438 #endif
47439 };
47440
47441 /* Create a variable linking object for use later */
47442 static PyObject *
47443 SWIG_Python_newvarlink(void) {
47444 swig_varlinkobject *result = 0;
47445 result = PyMem_NEW(swig_varlinkobject,1);
47446 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47447 result->ob_type = &varlinktype;
47448 result->vars = 0;
47449 result->ob_refcnt = 0;
47450 Py_XINCREF((PyObject *) result);
47451 return ((PyObject*) result);
47452 }
47453
47454 static void
47455 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47456 swig_varlinkobject *v;
47457 swig_globalvar *gv;
47458 v= (swig_varlinkobject *) p;
47459 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47460 gv->name = (char *) malloc(strlen(name)+1);
47461 strcpy(gv->name,name);
47462 gv->get_attr = get_attr;
47463 gv->set_attr = set_attr;
47464 gv->next = v->vars;
47465 v->vars = gv;
47466 }
47467
47468 /* -----------------------------------------------------------------------------
47469 * constants/methods manipulation
47470 * ----------------------------------------------------------------------------- */
47471
47472 /* Install Constants */
47473 static void
47474 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47475 PyObject *obj = 0;
47476 size_t i;
47477 for (i = 0; constants[i].type; i++) {
47478 switch(constants[i].type) {
47479 case SWIG_PY_INT:
47480 obj = PyInt_FromLong(constants[i].lvalue);
47481 break;
47482 case SWIG_PY_FLOAT:
47483 obj = PyFloat_FromDouble(constants[i].dvalue);
47484 break;
47485 case SWIG_PY_STRING:
47486 if (constants[i].pvalue) {
47487 obj = PyString_FromString((char *) constants[i].pvalue);
47488 } else {
47489 Py_INCREF(Py_None);
47490 obj = Py_None;
47491 }
47492 break;
47493 case SWIG_PY_POINTER:
47494 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47495 break;
47496 case SWIG_PY_BINARY:
47497 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47498 break;
47499 default:
47500 obj = 0;
47501 break;
47502 }
47503 if (obj) {
47504 PyDict_SetItemString(d,constants[i].name,obj);
47505 Py_DECREF(obj);
47506 }
47507 }
47508 }
47509
47510 /* -----------------------------------------------------------------------------*/
47511 /* Fix SwigMethods to carry the callback ptrs when needed */
47512 /* -----------------------------------------------------------------------------*/
47513
47514 static void
47515 SWIG_Python_FixMethods(PyMethodDef *methods,
47516 swig_const_info *const_table,
47517 swig_type_info **types,
47518 swig_type_info **types_initial) {
47519 size_t i;
47520 for (i = 0; methods[i].ml_name; ++i) {
47521 char *c = methods[i].ml_doc;
47522 if (c && (c = strstr(c, "swig_ptr: "))) {
47523 int j;
47524 swig_const_info *ci = 0;
47525 char *name = c + 10;
47526 for (j = 0; const_table[j].type; j++) {
47527 if (strncmp(const_table[j].name, name,
47528 strlen(const_table[j].name)) == 0) {
47529 ci = &(const_table[j]);
47530 break;
47531 }
47532 }
47533 if (ci) {
47534 size_t shift = (ci->ptype) - types;
47535 swig_type_info *ty = types_initial[shift];
47536 size_t ldoc = (c - methods[i].ml_doc);
47537 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47538 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47539 char *buff = ndoc;
47540 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47541 strncpy(buff, methods[i].ml_doc, ldoc);
47542 buff += ldoc;
47543 strncpy(buff, "swig_ptr: ", 10);
47544 buff += 10;
47545 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47546 methods[i].ml_doc = ndoc;
47547 }
47548 }
47549 }
47550 }
47551
47552 /* -----------------------------------------------------------------------------*
47553 * Initialize type list
47554 * -----------------------------------------------------------------------------*/
47555
47556 #if PY_MAJOR_VERSION < 2
47557 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47558 is copied out of Python/modsupport.c in python version 2.3.4 */
47559 static int
47560 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47561 {
47562 PyObject *dict;
47563 if (!PyModule_Check(m)) {
47564 PyErr_SetString(PyExc_TypeError,
47565 "PyModule_AddObject() needs module as first arg");
47566 return -1;
47567 }
47568 if (!o) {
47569 PyErr_SetString(PyExc_TypeError,
47570 "PyModule_AddObject() needs non-NULL value");
47571 return -1;
47572 }
47573
47574 dict = PyModule_GetDict(m);
47575 if (dict == NULL) {
47576 /* Internal error -- modules must have a dict! */
47577 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47578 PyModule_GetName(m));
47579 return -1;
47580 }
47581 if (PyDict_SetItemString(dict, name, o))
47582 return -1;
47583 Py_DECREF(o);
47584 return 0;
47585 }
47586 #endif
47587
47588 static swig_type_info **
47589 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47590 static PyMethodDef swig_empty_runtime_method_table[] = {
47591 {
47592 NULL, NULL, 0, NULL
47593 }
47594 };/* Sentinel */
47595
47596 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47597 swig_empty_runtime_method_table);
47598 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47599 if (pointer && module) {
47600 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47601 }
47602 return type_list_handle;
47603 }
47604
47605 static swig_type_info **
47606 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47607 swig_type_info **type_pointer;
47608
47609 /* first check if module already created */
47610 type_pointer = SWIG_Python_GetTypeListHandle();
47611 if (type_pointer) {
47612 return type_pointer;
47613 } else {
47614 /* create a new module and variable */
47615 return SWIG_Python_SetTypeListHandle(type_list_handle);
47616 }
47617 }
47618
47619 #ifdef __cplusplus
47620 }
47621 #endif
47622
47623 /* -----------------------------------------------------------------------------*
47624 * Partial Init method
47625 * -----------------------------------------------------------------------------*/
47626
47627 #ifdef SWIG_LINK_RUNTIME
47628 #ifdef __cplusplus
47629 extern "C"
47630 #endif
47631 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47632 #endif
47633
47634 #ifdef __cplusplus
47635 extern "C"
47636 #endif
47637 SWIGEXPORT(void) SWIG_init(void) {
47638 static PyObject *SWIG_globals = 0;
47639 static int typeinit = 0;
47640 PyObject *m, *d;
47641 int i;
47642 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47643
47644 /* Fix SwigMethods to carry the callback ptrs when needed */
47645 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47646
47647 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47648 d = PyModule_GetDict(m);
47649
47650 if (!typeinit) {
47651 #ifdef SWIG_LINK_RUNTIME
47652 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47653 #else
47654 # ifndef SWIG_STATIC_RUNTIME
47655 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47656 # endif
47657 #endif
47658 for (i = 0; swig_types_initial[i]; i++) {
47659 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47660 }
47661 typeinit = 1;
47662 }
47663 SWIG_InstallConstants(d,swig_const_table);
47664
47665
47666 #ifndef wxPyUSE_EXPORT
47667 // Make our API structure a CObject so other modules can import it
47668 // from this module.
47669 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47670 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47671 Py_XDECREF(cobj);
47672 #endif
47673
47674 {
47675 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49326 }
49327 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49328 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49329 {
49330 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49331 }
49332 {
49333 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49376 }
49377 {
49378 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49379 }
49380 {
49381 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49382 }
49383 {
49384 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49385 }
49386 {
49387 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49388 }
49389 {
49390 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49391 }
49392 {
49393 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49394 }
49395 {
49396 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49397 }
49398 {
49399 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49400 }
49401 {
49402 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49436 }
49437 {
49438 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49481 }
49482 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49483 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49484 {
49485 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49492 }
49493
49494 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49495
49496
49497 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49498
49499 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49500 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49501 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49502 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49503 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49504 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49505 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49506 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49507 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49508 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49509 {
49510 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49514 }
49515 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49516 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49517 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49518 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49519 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49520 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49521 {
49522 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49538 }
49539 {
49540 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49541 }
49542 {
49543 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49550 }
49551 {
49552 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49553 }
49554 {
49555 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49556 }
49557 {
49558 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49559 }
49560 {
49561 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49562 }
49563 {
49564 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49565 }
49566 {
49567 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49568 }
49569 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49570 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49571 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49572 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49573 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49574 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49575 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49576 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49577 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49578 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49579 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49580 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49581 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49582 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49583 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49584 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49585 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49586 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49587 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49588 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49589 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49590 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49591 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49592 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49593 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49594 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49595 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49596 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49597 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49598 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49599 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49600 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49601 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49602 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49603 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49604 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49605 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49606 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49607 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49608 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49609 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49610 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49611 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49612 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49613 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49614 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49615 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49616 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49617 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49618 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49619 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49620 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49621 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49622 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49623 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49624 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49625 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49626 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49627 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49628 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49629 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49630 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49631 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49632 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49633 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49634 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49635 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49636 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49637 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49638 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49639 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49640 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49641 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49642 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49643 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49644 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49645 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49646 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49647 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49648 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49649 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49650 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49651 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49652 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49653 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49654 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49655 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49656 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49657 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49658 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49659 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49660 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49661 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49662 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49663 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49664 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49665 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49666 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49667 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49668 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49669 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49670 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49671 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49672 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49673 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49674 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49675 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49676 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49677 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49678 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49679 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49680 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49681 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49682 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49683 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49684 {
49685 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49686 }
49687 {
49688 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49689 }
49690 {
49691 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49692 }
49693 {
49694 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49695 }
49696 {
49697 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49698 }
49699 {
49700 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49701 }
49702 {
49703 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49704 }
49705 {
49706 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49707 }
49708 {
49709 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49710 }
49711 {
49712 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49713 }
49714 {
49715 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49716 }
49717 {
49718 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49719 }
49720 {
49721 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49722 }
49723 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49724 {
49725 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49726 }
49727 {
49728 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49729 }
49730 {
49731 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49732 }
49733 {
49734 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49735 }
49736 {
49737 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49738 }
49739 {
49740 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49741 }
49742 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49743 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49744 {
49745 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49746 }
49747 {
49748 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49749 }
49750 {
49751 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49752 }
49753 {
49754 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49755 }
49756 {
49757 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49758 }
49759 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49760 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49761 {
49762 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49763 }
49764 {
49765 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49766 }
49767 {
49768 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49769 }
49770 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49771 {
49772 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49782 }
49783 {
49784 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49785 }
49786 {
49787 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49788 }
49789 {
49790 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49791 }
49792 {
49793 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49794 }
49795 {
49796 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49797 }
49798 {
49799 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49800 }
49801 {
49802 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49803 }
49804 {
49805 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49806 }
49807 {
49808 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49809 }
49810 {
49811 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49812 }
49813 {
49814 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49815 }
49816 {
49817 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49818 }
49819 {
49820 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49821 }
49822 {
49823 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49824 }
49825 {
49826 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49827 }
49828
49829 // Initialize threading, some globals and such
49830 __wxPyPreStart(d);
49831
49832
49833 // Although these are defined in __version__ they need to be here too so
49834 // that an assert can be done to ensure that the wxPython and the wxWindows
49835 // versions match.
49836 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49837 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49838 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49839
49840 }
49841
wxWidgets (Impactor)